Properly defer evaluation of consts with infers/params

Author: BoxyUwU

compiler/rustc_middle/src/ty/context.rs

@@ -761,6 +761,10 @@ impl<'tcx> rustc_type_ir::inherent::Safety<TyCtxt<'tcx>> for hir::Safety {
 }
 
 impl<'tcx> rustc_type_ir::inherent::Features<TyCtxt<'tcx>> for &'tcx rustc_feature::Features {
+    fn min_generic_const_args(self) -> bool {
+        self.min_generic_const_args()
+    }
+
     fn generic_const_exprs(self) -> bool {
         self.generic_const_exprs()
     }

compiler/rustc_next_trait_solver/src/solve/mod.rs

@@ -143,14 +143,26 @@ where
     ) -> QueryResult<I> {
         match ct.kind() {
             ty::ConstKind::Unevaluated(uv) => {
+                // `ConstEvaluatable` goals don't really need to exist under `mgca` as we can assume all
+                // generic const args can be sucessfully evaluated as they have been checked at def site.
+                //
+                // The only reason we keep this around is so that wf checking of signatures is guaranteed
+                // to wind up normalizing constants emitting errors if they are ill formed. The equivalent
+                // check does not exist for types and results in diverging aliases not being normalized during
+                // wfck sometimes.
+                //
+                // Regardless, the point being that the behaviour of this goal doesn't really matter so we just
+                // always return `Ok` and evaluate for the CTFE side effect of emitting an error.
+                if self.cx().features().min_generic_const_args() {
+                    let _ = self.evaluate_const(param_env, uv);
+                    return self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes);
+                }
+
                 // We never return `NoSolution` here as `evaluate_const` emits an
                 // error itself when failing to evaluate, so emitting an additional fulfillment
                 // error in that case is unnecessary noise. This may change in the future once
                 // evaluation failures are allowed to impact selection, e.g. generic const
                 // expressions in impl headers or `where`-clauses.
-
-                // FIXME(generic_const_exprs): Implement handling for generic
-                // const expressions here.
                 if let Some(_normalized) = self.evaluate_const(param_env, uv) {
                     self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
                 } else {

compiler/rustc_trait_selection/src/traits/const_evaluatable.rs

@@ -86,9 +86,16 @@ pub fn is_const_evaluatable<'tcx>(
             _ => bug!("unexpected constkind in `is_const_evalautable: {unexpanded_ct:?}`"),
         }
     } else if tcx.features().min_generic_const_args() {
-        // This is a sanity check to make sure that non-generics consts are checked to
-        // be evaluatable in case they aren't cchecked elsewhere. This will NOT error
-        // if the const uses generics, as desired.
+        // `ConstEvaluatable` goals don't really need to exist under `mgca` as we can assume all
+        // generic const args can be sucessfully evaluated as they have been checked at def site.
+        //
+        // The only reason we keep this around is so that wf checking of signatures is guaranteed
+        // to wind up normalizing constants emitting errors if they are ill formed. The equivalent
+        // check does not exist for types and results in diverging aliases not being normalized during
+        // wfck sometimes.
+        //
+        // Regardless, the point being that the behaviour of this goal doesn't really matter so we just
+        // always return `Ok` and evaluate for the CTFE side effect of emitting an error.
         crate::traits::evaluate_const(infcx, unexpanded_ct, param_env);
         Ok(())
     } else {

compiler/rustc_trait_selection/src/traits/mod.rs

@@ -547,7 +547,7 @@ pub fn try_evaluate_const<'tcx>(
             // Postpone evaluation of constants that depend on generic parameters or
             // inference variables.
             //
-            // We use `TypingMode::PostAnalysis`  here which is not *technically* correct
+            // We use `TypingMode::PostAnalysis` here which is not *technically* correct
             // to be revealing opaque types here as borrowcheck has not run yet. However,
             // CTFE itself uses `TypingMode::PostAnalysis` unconditionally even during
             // typeck and not doing so has a lot of (undesirable) fallout (#101478, #119821).
@@ -557,68 +557,90 @@ pub fn try_evaluate_const<'tcx>(
             // instead of having this logic here
             let (args, typing_env) = if tcx.def_kind(uv.def) == DefKind::AnonConst
                 && let ty::AnonConstKind::GCEConst = tcx.anon_const_kind(uv.def)
-                && uv.has_non_region_infer()
             {
-                // `feature(generic_const_exprs)` causes anon consts to inherit all parent generics. This can cause
-                // inference variables and generic parameters to show up in `ty::Const` even though the anon const
-                // does not actually make use of them. We handle this case specially and attempt to evaluate anyway.
-                match tcx.thir_abstract_const(uv.def) {
-                    Ok(Some(ct)) => {
-                        let ct = tcx.expand_abstract_consts(ct.instantiate(tcx, uv.args));
-                        if let Err(e) = ct.error_reported() {
-                            return Err(EvaluateConstErr::EvaluationFailure(e));
-                        } else if ct.has_non_region_infer() || ct.has_non_region_param() {
-                            // If the anon const *does* actually use generic parameters or inference variables from
-                            // the generic arguments provided for it, then we should *not* attempt to evaluate it.
-                            return Err(EvaluateConstErr::HasGenericsOrInfers);
-                        } else {
-                            let args = replace_param_and_infer_args_with_placeholder(tcx, uv.args);
-                            let typing_env = infcx
-                                .typing_env(tcx.erase_regions(param_env))
-                                .with_post_analysis_normalized(tcx);
+                // We handle `generic_const_exprs` separately as reasonable ways of handling constants in the type system
+                // completely fall apart under `generic_const_exprs` and makes this whole function Really hard to reason
+                // about if you have to consider gce whatsoever.
+
+                if uv.has_non_region_infer() || uv.has_non_region_param() {
+                    // `feature(generic_const_exprs)` causes anon consts to inherit all parent generics. This can cause
+                    // inference variables and generic parameters to show up in `ty::Const` even though the anon const
+                    // does not actually make use of them. We handle this case specially and attempt to evaluate anyway.
+                    match tcx.thir_abstract_const(uv.def) {
+                        Ok(Some(ct)) => {
+                            let ct = tcx.expand_abstract_consts(ct.instantiate(tcx, uv.args));
+                            if let Err(e) = ct.error_reported() {
+                                return Err(EvaluateConstErr::EvaluationFailure(e));
+                            } else if ct.has_non_region_infer() || ct.has_non_region_param() {
+                                // If the anon const *does* actually use generic parameters or inference variables from
+                                // the generic arguments provided for it, then we should *not* attempt to evaluate it.
+                                return Err(EvaluateConstErr::HasGenericsOrInfers);
+                            } else {
+                                let args =
+                                    replace_param_and_infer_args_with_placeholder(tcx, uv.args);
+                                let typing_env = infcx
+                                    .typing_env(tcx.erase_regions(param_env))
+                                    .with_post_analysis_normalized(tcx);
+                                (args, typing_env)
+                            }
+                        }
+                        Err(_) | Ok(None) => {
+                            let args = GenericArgs::identity_for_item(tcx, uv.def);
+                            let typing_env = ty::TypingEnv::post_analysis(tcx, uv.def);
                             (args, typing_env)
                         }
                     }
-                    Err(_) | Ok(None) => {
-                        let args = GenericArgs::identity_for_item(tcx, uv.def);
-                        let typing_env = ty::TypingEnv::post_analysis(tcx, uv.def);
-                        (args, typing_env)
-                    }
+                } else {
+                    let typing_env = infcx
+                        .typing_env(tcx.erase_regions(param_env))
+                        .with_post_analysis_normalized(tcx);
+                    (uv.args, typing_env)
                 }
             } else if tcx.def_kind(uv.def) == DefKind::AnonConst
                 && let ty::AnonConstKind::RepeatExprCount = tcx.anon_const_kind(uv.def)
-                && uv.has_non_region_infer()
             {
-                // FIXME: remove this when `const_evaluatable_unchecked` is a hard error.
-                //
-                // Diagnostics will sometimes replace the identity args of anon consts in
-                // array repeat expr counts with inference variables so we have to handle this
-                // even though it is not something we should ever actually encounter.
-                //
-                // Array repeat expr counts are allowed to syntactically use generic parameters
-                // but must not actually depend on them in order to evalaute successfully. This means
-                // that it is actually fine to evalaute them in their own environment rather than with
-                // the actually provided generic arguments.
-                tcx.dcx().delayed_bug(
-                    "Encountered anon const with inference variable args but no error reported",
-                );
+                if uv.has_non_region_infer() {
+                    // Diagnostics will sometimes replace the identity args of anon consts in
+                    // array repeat expr counts with inference variables so we have to handle this
+                    // even though it is not something we should ever actually encounter.
+                    //
+                    // Array repeat expr counts are allowed to syntactically use generic parameters
+                    // but must not actually depend on them in order to evalaute successfully. This means
+                    // that it is actually fine to evalaute them in their own environment rather than with
+                    // the actually provided generic arguments.
+                    tcx.dcx().delayed_bug(
+                        "Encountered anon const with inference variable args but no error reported",
+                    );
+                }
 
+                // The generic args of repeat expr counts under `min_const_generics` are not supposed to
+                // affect evaluation of the constant as this would make it a "truly" generic const arg.
+                // To prevent this we discard all the generic arguments and evalaute with identity args
+                // and in its own environment instead of the current environment we are normalizing in.
                 let args = GenericArgs::identity_for_item(tcx, uv.def);
                 let typing_env = ty::TypingEnv::post_analysis(tcx, uv.def);
 
                 (args, typing_env)
             } else {
-                // FIXME: This codepath is reachable under `associated_const_equality` and in the
-                // future will be reachable by `min_generic_const_args`. We should handle inference
-                // variables and generic parameters properly instead of doing nothing.
+                // We are only dealing with "truly" generic/uninferred constants here:
+                // - GCEConsts have been handled separately
+                // - Repeat expr count back compat consts have also been handled separately
+                // So we are free to simply defer evaluation here.
+                //
+                // FIXME: This assumes that `args` are normalized which is not necessarily true
+                if uv.args.has_non_region_param() || uv.args.has_non_region_infer() {
+                    return Err(EvaluateConstErr::HasGenericsOrInfers);
+                }
+
                 let typing_env = infcx
                     .typing_env(tcx.erase_regions(param_env))
                     .with_post_analysis_normalized(tcx);
                 (uv.args, typing_env)
             };
-            let uv = ty::UnevaluatedConst::new(uv.def, args);
 
+            let uv = ty::UnevaluatedConst::new(uv.def, args);
             let erased_uv = tcx.erase_regions(uv);
+
             use rustc_middle::mir::interpret::ErrorHandled;
             match tcx.const_eval_resolve_for_typeck(typing_env, erased_uv, DUMMY_SP) {
                 Ok(Ok(val)) => Ok(ty::Const::new_value(

compiler/rustc_type_ir/src/inherent.rs

@@ -570,6 +570,8 @@ pub trait ParamEnv<I: Interner>: Copy + Debug + Hash + Eq + TypeFoldable<I> {
 }
 
 pub trait Features<I: Interner>: Copy {
+    fn min_generic_const_args(self) -> bool;
+
     fn generic_const_exprs(self) -> bool;
 
     fn coroutine_clone(self) -> bool;