[experiment] turn on effects everywhere

Author: fee1-dead

compiler/rustc_ast_lowering/src/item.rs

@@ -571,7 +571,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             hir::ItemKind::Impl(impl_) => {
                 self.is_in_trait_impl = impl_.of_trait.is_some();
             }
-            hir::ItemKind::Trait(_, _, generics, _, _) if self.tcx.features().effects => {
+            hir::ItemKind::Trait(_, _, generics, _, _) => {
                 self.host_param_id = generics
                     .params
                     .iter()
@@ -1391,9 +1391,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         // Desugar `~const` bound in generics into an additional `const host: bool` param
         // if the effects feature is enabled. This needs to be done before we lower where
         // clauses since where clauses need to bind to the DefId of the host param
-        let host_param_parts = if let Const::Yes(span) = constness
-            && self.tcx.features().effects
-        {
+        let host_param_parts = if let Const::Yes(span) = constness {
             let span = self.lower_span(span);
             let param_node_id = self.next_node_id();
             let hir_id = self.next_id();

compiler/rustc_ast_lowering/src/lib.rs

@@ -2556,10 +2556,6 @@ struct GenericArgsCtor<'hir> {
 
 impl<'hir> GenericArgsCtor<'hir> {
     fn push_constness(&mut self, lcx: &mut LoweringContext<'_, 'hir>, constness: ast::Const) {
-        if !lcx.tcx.features().effects {
-            return;
-        }
-
         // if bound is non-const, don't add host effect param
         let ast::Const::Yes(span) = constness else { return };
 

compiler/rustc_const_eval/src/transform/check_consts/check.rs

@@ -763,33 +763,16 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
                     // the trait into the concrete method, and uses that for const stability
                     // checks.
                     // FIXME(effects) we might consider moving const stability checks to typeck as well.
-                    if tcx.features().effects {
-                        is_trait = true;
+                    is_trait = true;
 
-                        if let Ok(Some(instance)) =
-                            Instance::resolve(tcx, param_env, callee, fn_args)
-                            && let InstanceDef::Item(def) = instance.def
-                        {
-                            // Resolve a trait method call to its concrete implementation, which may be in a
-                            // `const` trait impl. This is only used for the const stability check below, since
-                            // we want to look at the concrete impl's stability.
-                            fn_args = instance.args;
-                            callee = def;
-                        }
-                    } else {
-                        self.check_op(ops::FnCallNonConst {
-                            caller,
-                            callee,
-                            args: fn_args,
-                            span: *fn_span,
-                            call_source: *call_source,
-                            feature: Some(if tcx.features().const_trait_impl {
-                                sym::effects
-                            } else {
-                                sym::const_trait_impl
-                            }),
-                        });
-                        return;
+                    if let Ok(Some(instance)) = Instance::resolve(tcx, param_env, callee, fn_args)
+                        && let InstanceDef::Item(def) = instance.def
+                    {
+                        // Resolve a trait method call to its concrete implementation, which may be in a
+                        // `const` trait impl. This is only used for the const stability check below, since
+                        // we want to look at the concrete impl's stability.
+                        fn_args = instance.args;
+                        callee = def;
                     }
                 }
 

compiler/rustc_const_eval/src/transform/check_consts/qualifs.rs

@@ -157,9 +157,7 @@ impl Qualif for NeedsNonConstDrop {
         // FIXME(effects): If `destruct` is not a `const_trait`,
         // or effects are disabled in this crate, then give up.
         let destruct_def_id = cx.tcx.require_lang_item(LangItem::Destruct, Some(cx.body.span));
-        if cx.tcx.generics_of(destruct_def_id).host_effect_index.is_none()
-            || !cx.tcx.features().effects
-        {
+        if cx.tcx.generics_of(destruct_def_id).host_effect_index.is_none() {
             return NeedsDrop::in_any_value_of_ty(cx, ty);
         }
 

compiler/rustc_hir_analysis/src/bounds.rs

@@ -47,8 +47,7 @@ impl<'tcx> Bounds<'tcx> {
         self.push_trait_bound_inner(tcx, trait_ref, span, polarity);
 
         // push a non-const (`host = true`) version of the bound if it is `~const`.
-        if tcx.features().effects
-            && let Some(host_effect_idx) = tcx.generics_of(trait_ref.def_id()).host_effect_index
+        if let Some(host_effect_idx) = tcx.generics_of(trait_ref.def_id()).host_effect_index
             && trait_ref.skip_binder().args.const_at(host_effect_idx) != tcx.consts.true_
         {
             let generics = tcx.generics_of(trait_ref.def_id());

compiler/rustc_hir_analysis/src/collect/predicates_of.rs

@@ -38,7 +38,7 @@ pub(super) fn predicates_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::GenericPredic
         // an obligation and instead be skipped. Otherwise we'd use
         // `tcx.def_span(def_id);`
         let span = rustc_span::DUMMY_SP;
-        let non_const_bound = if tcx.features().effects && tcx.has_attr(def_id, sym::const_trait) {
+        let non_const_bound = if tcx.has_attr(def_id, sym::const_trait) {
             // when `Self` is a const trait, also add `Self: Trait<.., true>` as implied bound,
             // because only implementing `Self: Trait<.., false>` is currently not possible.
             Some((

compiler/rustc_middle/src/ty/util.rs

@@ -790,8 +790,7 @@ impl<'tcx> TyCtxt<'tcx> {
         // FIXME(effects): This is suspicious and should probably not be done,
         // especially now that we enforce host effects and then properly handle
         // effect vars during fallback.
-        let mut host_always_on =
-            !self.features().effects || self.sess.opts.unstable_opts.unleash_the_miri_inside_of_you;
+        let mut host_always_on = self.sess.opts.unstable_opts.unleash_the_miri_inside_of_you;
 
         // Compute the constness required by the context.
         let const_context = self.hir().body_const_context(def_id);