implement ~const Tr bounds under new desugaring

Author: fee1-dead

compiler/rustc_hir_analysis/src/astconv/mod.rs

@@ -675,7 +675,8 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
             args,
             trait_segment.infer_args,
             Some(self_ty),
-            constness,
+            // TODO: remove this!!!
+            ty::BoundConstness::NotConst,
         );
 
         let tcx = self.tcx();
@@ -688,7 +689,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
         );
 
         debug!(?poly_trait_ref);
-        bounds.push_trait_bound(tcx, poly_trait_ref, span, polarity);
+        bounds.push_trait_bound(tcx, self.item_def_id(), poly_trait_ref, span, polarity, constness);
 
         let mut dup_bindings = FxIndexMap::default();
         for binding in args.bindings {

compiler/rustc_hir_analysis/src/bounds.rs

@@ -3,7 +3,7 @@
 
 use rustc_hir::LangItem;
 use rustc_middle::ty::{self, ToPredicate, Ty, TyCtxt};
-use rustc_span::Span;
+use rustc_span::{def_id::DefId, Span};
 
 /// Collects together a list of type bounds. These lists of bounds occur in many places
 /// in Rust's syntax:
@@ -40,19 +40,11 @@ impl<'tcx> Bounds<'tcx> {
     pub fn push_trait_bound(
         &mut self,
         tcx: TyCtxt<'tcx>,
+        defining_def_id: DefId,
         trait_ref: ty::PolyTraitRef<'tcx>,
         span: Span,
         polarity: ty::ImplPolarity,
-    ) {
-        self.push_trait_bound_inner(tcx, trait_ref, span, polarity);
-    }
-
-    fn push_trait_bound_inner(
-        &mut self,
-        tcx: TyCtxt<'tcx>,
-        trait_ref: ty::PolyTraitRef<'tcx>,
-        span: Span,
-        polarity: ty::ImplPolarity,
+        constness: ty::BoundConstness,
     ) {
         self.clauses.push((
             trait_ref
@@ -62,6 +54,28 @@ impl<'tcx> Bounds<'tcx> {
                 .to_predicate(tcx),
             span,
         ));
+        // For `T: ~const Tr` or `T: const Tr`, we need to add an additional bound on the
+        // associated type of `<T as Tr>` and make sure that the effect is compatible.
+        if let Some(compat_val) = match constness {
+            // TODO: do we need `T: const Trait` anymore?
+            ty::BoundConstness::Const => Some(tcx.consts.false_),
+            ty::BoundConstness::ConstIfConst => {
+                Some(tcx.expected_host_effect_param_for_body(defining_def_id))
+            }
+            ty::BoundConstness::NotConst => None,
+        } {
+            // create a new projection type `<T as Tr>::Effects`
+            let assoc = tcx.associated_type_for_effects(trait_ref.def_id()).unwrap();
+            let self_ty = Ty::new_projection(tcx, assoc, trait_ref.skip_binder().args);
+            // make `<T as Tr>::Effects: Compat<runtime>`
+            let new_trait_ref = ty::TraitRef::new(tcx, tcx.require_lang_item(LangItem::EffectsCompat, Some(span)), [ty::GenericArg::from(self_ty), compat_val.into()]);
+            self.clauses.push((
+                trait_ref
+                    .rebind(new_trait_ref)
+                    .to_predicate(tcx),
+                span,
+            ));
+        }
     }
 
     pub fn push_projection_bound(

compiler/rustc_hir_analysis/src/collect/predicates_of.rs

@@ -116,8 +116,7 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Gen
         let parent = tcx.local_parent(def_id);
 
         let identity_args = ty::GenericArgs::identity_for_item(tcx, def_id);
-        predicates
-            .extend(tcx.explicit_predicates_of(parent).instantiate_own(tcx, identity_args));
+        predicates.extend(tcx.explicit_predicates_of(parent).instantiate_own(tcx, identity_args));
         return ty::GenericPredicates {
             parent: Some(parent.to_def_id()),
             predicates: tcx.arena.alloc_from_iter(predicates),

compiler/rustc_metadata/src/rmeta/decoder.rs

@@ -1293,7 +1293,9 @@ impl<'a, 'tcx> CrateMetadataRef<'a> {
     }
 
     fn get_associated_item(self, id: DefIndex, sess: &'a Session) -> ty::AssocItem {
-        let name = if self.root.tables.opt_rpitit_info.get(self, id).is_some() || self.root.tables.is_effects_desugaring.get(self, id) {
+        let name = if self.root.tables.opt_rpitit_info.get(self, id).is_some()
+            || self.root.tables.is_effects_desugaring.get(self, id)
+        {
             kw::Empty
         } else {
             self.item_name(id)