Rename the FIXMEs, remove a few that dont matter anymore

Author: compiler-errors

compiler/rustc_ast_passes/src/errors.rs

@@ -594,8 +594,8 @@ pub(crate) struct ConstBoundTraitObject {
     pub span: Span,
 }
 
-// FIXME(effects): Consider making the note/reason the message of the diagnostic.
-// FIXME(effects): Provide structured suggestions (e.g., add `const` / `#[const_trait]` here).
+// FIXME(const_trait_impl): Consider making the note/reason the message of the diagnostic.
+// FIXME(const_trait_impl): Provide structured suggestions (e.g., add `const` / `#[const_trait]` here).
 #[derive(Diagnostic)]
 #[diag(ast_passes_tilde_const_disallowed)]
 pub(crate) struct TildeConstDisallowed {

compiler/rustc_const_eval/src/check_consts/check.rs

@@ -657,7 +657,8 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
                     // typeck ensures the conditions for calling a const trait method are met,
                     // so we only error if the trait isn't const. We try to resolve 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.
+                    // FIXME(const_trait_impl) we might consider moving const stability checks
+                    // to typeck as well.
                     if tcx.features().const_trait_impl() && trait_is_const {
                         // This skips the check below that ensures we only call `const fn`.
                         is_trait = true;

compiler/rustc_const_eval/src/check_consts/ops.rs

@@ -120,7 +120,7 @@ impl<'tcx> NonConstOp<'tcx> for FnCallNonConst<'tcx> {
                     let implsrc = selcx.select(&obligation);
 
                     if let Ok(Some(ImplSource::UserDefined(data))) = implsrc {
-                        // FIXME(effects) revisit this
+                        // FIXME(const_trait_impl) revisit this
                         if !tcx.is_const_trait_impl(data.impl_def_id) {
                             let span = tcx.def_span(data.impl_def_id);
                             err.subdiagnostic(errors::NonConstImplNote { span });

compiler/rustc_const_eval/src/check_consts/qualifs.rs

@@ -192,7 +192,7 @@ impl Qualif for NeedsNonConstDrop {
             return false;
         }
 
-        // FIXME(effects): Reimplement const drop checking.
+        // FIXME(const_trait_impl): Reimplement const drop checking.
         NeedsDrop::in_any_value_of_ty(cx, ty)
     }
 

compiler/rustc_const_eval/src/const_eval/machine.rs

@@ -431,7 +431,7 @@ impl<'tcx> interpret::Machine<'tcx> for CompileTimeMachine<'tcx> {
             // sensitive check here. But we can at least rule out functions that are not const at
             // all. That said, we have to allow calling functions inside a trait marked with
             // #[const_trait]. These *are* const-checked!
-            // FIXME(effects): why does `is_const_fn` not classify them as const?
+            // FIXME(const_trait_impl): why does `is_const_fn` not classify them as const?
             if (!ecx.tcx.is_const_fn(def) && !ecx.tcx.is_const_default_method(def))
                 || ecx.tcx.has_attr(def, sym::rustc_do_not_const_check)
             {

compiler/rustc_hir_analysis/src/check/compare_impl_item.rs

@@ -205,7 +205,6 @@ fn compare_method_predicate_entailment<'tcx>(
         trait_m_predicates.instantiate_own(tcx, trait_to_impl_args).map(|(predicate, _)| predicate),
     );
 
-    // FIXME(effects): This should be replaced with a more dedicated method.
     let is_conditionally_const = tcx.is_conditionally_const(impl_def_id);
     if is_conditionally_const {
         // Augment the hybrid param-env with the const conditions

compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs

@@ -563,7 +563,6 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                         if let Err(guar) = ty.error_reported() {
                             return ty::Const::new_error(tcx, guar).into();
                         }
-                        // FIXME(effects) see if we should special case effect params here
                         if !infer_args && has_default {
                             tcx.const_param_default(param.def_id)
                                 .instantiate(tcx, preceding_args)

compiler/rustc_hir_analysis/src/impl_wf_check/min_specialization.rs

@@ -459,7 +459,7 @@ fn trait_predicates_eq<'tcx>(
     predicate1: ty::Predicate<'tcx>,
     predicate2: ty::Predicate<'tcx>,
 ) -> bool {
-    // FIXME(effects)
+    // FIXME(const_trait_impl)
     predicate1 == predicate2
 }
 

compiler/rustc_hir_typeck/src/callee.rs

@@ -461,7 +461,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 }
                 (fn_sig, Some(def_id))
             }
-            // FIXME(effects): these arms should error because we can't enforce them
+            // FIXME(const_trait_impl): these arms should error because we can't enforce them
             ty::FnPtr(sig_tys, hdr) => (sig_tys.with(hdr), None),
             _ => {
                 for arg in arg_exprs {
@@ -843,7 +843,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         callee_did: DefId,
         callee_args: GenericArgsRef<'tcx>,
     ) {
-        // FIXME(effects): We should be enforcing these effects unconditionally.
+        // FIXME(const_trait_impl): We should be enforcing these effects unconditionally.
         // This can be done as soon as we convert the standard library back to
         // using const traits, since if we were to enforce these conditions now,
         // we'd fail on basically every builtin trait call (i.e. `1 + 2`).
@@ -864,11 +864,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             None => return,
         };
 
-        // FIXME(effects): Should this be `is_const_fn_raw`? It depends on if we move
+        // FIXME(const_trait_impl): Should this be `is_const_fn_raw`? It depends on if we move
         // const stability checking here too, I guess.
         if self.tcx.is_conditionally_const(callee_did) {
             let q = self.tcx.const_conditions(callee_did);
-            // FIXME(effects): Use this span with a better cause code.
+            // FIXME(const_trait_impl): Use this span with a better cause code.
             for (cond, _) in q.instantiate(self.tcx, callee_args) {
                 self.register_predicate(Obligation::new(
                     self.tcx,
@@ -878,7 +878,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 ));
             }
         } else {
-            // FIXME(effects): This should eventually be caught here.
+            // FIXME(const_trait_impl): This should eventually be caught here.
             // For now, though, we defer some const checking to MIR.
         }
     }

compiler/rustc_middle/src/ty/context.rs

@@ -3125,7 +3125,6 @@ impl<'tcx> TyCtxt<'tcx> {
             }
     }
 
-    // FIXME(effects): Please remove this. It's a footgun.
     /// Whether the trait impl is marked const. This does not consider stability or feature gates.
     pub fn is_const_trait_impl(self, def_id: DefId) -> bool {
         self.def_kind(def_id) == DefKind::Impl { of_trait: true }