Introduce evaluate const err kind for impossible preds

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/solve/delegate.rs

@@ -85,7 +85,9 @@ impl<'tcx> rustc_next_trait_solver::delegate::SolverDelegate for SolverDelegate<
             Ok(ct) => Some(ct),
             Err(EvaluateConstErr::EvaluationFailure(e)) => Some(ty::Const::new_error(self.tcx, e)),
             Err(
-                EvaluateConstErr::InvalidConstParamTy(_) | EvaluateConstErr::HasGenericsOrInfers,
+                EvaluateConstErr::ImpossibleClauses
+                | EvaluateConstErr::InvalidConstParamTy(_)
+                | EvaluateConstErr::HasGenericsOrInfers,
             ) => None,
         }
     }

compiler/rustc_trait_selection/src/traits/const_evaluatable.rs

@@ -76,6 +76,9 @@ pub fn is_const_evaluatable<'tcx>(
                             "Missing value for constant, but no error reported?",
                         )))
                     }
+                    Err(EvaluateConstErr::ImpossibleClauses) => {
+                        unreachable!("under gce constants shouldnt be wf checked before evaluating")
+                    }
                     Err(
                         EvaluateConstErr::EvaluationFailure(e)
                         | EvaluateConstErr::InvalidConstParamTy(e),
@@ -86,9 +89,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 {
@@ -144,6 +154,12 @@ pub fn is_const_evaluatable<'tcx>(
 
                 Err(err)
             }
+            Err(EvaluateConstErr::ImpossibleClauses) => {
+                let e = tcx
+                    .dcx()
+                    .delayed_bug("constants with impossible preds shouldnt error on stable");
+                return Err(NotConstEvaluatable::Error(e));
+            }
             Err(
                 EvaluateConstErr::EvaluationFailure(e) | EvaluateConstErr::InvalidConstParamTy(e),
             ) => Err(NotConstEvaluatable::Error(e)),

compiler/rustc_trait_selection/src/traits/fulfill.rs

@@ -687,7 +687,8 @@ impl<'a, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'tcx> {
                                 }
                                 e @ Err(
                                     EvaluateConstErr::EvaluationFailure(_)
-                                    | EvaluateConstErr::InvalidConstParamTy(_),
+                                    | EvaluateConstErr::InvalidConstParamTy(_)
+                                    | EvaluateConstErr::ImpossibleClauses,
                                 ) => e,
                             }
                         } else {
@@ -715,6 +716,10 @@ impl<'a, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'tcx> {
                                 }
                             }
                         }
+                        (Err(EvaluateConstErr::ImpossibleClauses), _)
+                        | (_, Err(EvaluateConstErr::ImpossibleClauses)) => unreachable!(
+                            "under gce constants shouldnt be wf checked before evaluating"
+                        ),
                         (Err(EvaluateConstErr::InvalidConstParamTy(e)), _)
                         | (_, Err(EvaluateConstErr::InvalidConstParamTy(e))) => {
                             ProcessResult::Error(FulfillmentErrorCode::Select(

compiler/rustc_trait_selection/src/traits/mod.rs

@@ -493,6 +493,10 @@ pub enum EvaluateConstErr {
     /// CTFE failed to evaluate the constant in some unrecoverable way (e.g. encountered a `panic!`).
     /// This is also used when the constant was already tainted by error.
     EvaluationFailure(ErrorGuaranteed),
+    /// The constant requires impossible clauses to hold in order for it to be evaluated. This does not
+    /// necessarily imply that type checking should error as there may be similar impossible clauses in
+    /// the type checking environment that can be used to prove this constant wf.
+    ImpossibleClauses,
 }
 
 // FIXME(BoxyUwU): Private this once we `generic_const_exprs` isn't doing its own normalization routine
@@ -514,7 +518,7 @@ pub fn evaluate_const<'tcx>(
         Err(EvaluateConstErr::EvaluationFailure(e) | EvaluateConstErr::InvalidConstParamTy(e)) => {
             ty::Const::new_error(infcx.tcx, e)
         }
-        Err(EvaluateConstErr::HasGenericsOrInfers) => ct,
+        Err(EvaluateConstErr::ImpossibleClauses | EvaluateConstErr::HasGenericsOrInfers) => ct,
     }
 }
 
@@ -671,7 +675,7 @@ pub fn try_evaluate_const<'tcx>(
                 // If we are dealing with a fully monomorphic constant then we should ensure that
                 // it is well formed as otherwise CTFE will ICE. For the same reasons as with
                 // deferring evaluation of generic/uninferred constants, we do not have to worry
-                // about `generic_const_expr`
+                // about `generic_const_exprs`
                 //
                 // This check is done in an empty environment which is a little weird, however, mir
                 // bodies with impossible predicates (in an empty environment) are sometimes built as
@@ -681,17 +685,9 @@ pub fn try_evaluate_const<'tcx>(
                     uv.def,
                     tcx.erase_regions(uv.args),
                 )) {
-                    // We treat these consts as rigid instead of an error or delaying a bug as we may
-                    // be checking a constant with a trivialy-false where clause that is satisfied from
-                    // a trivially-false clause in the environment.
-                    //
-                    // Delaying a bug would ICE the compiler as we may be in an environment where the
-                    // impossible pred actually holds.
-                    //
-                    // Emitting an error would be wrong as we may be normalizing inside of a probe where
-                    // an inference variable was inferred to a concrete value resulting in an impossible
-                    // predicate.
-                    return Ok(ct);
+                    // We can't delay a bug here as that could ICE the compiler if we are in an environment
+                    // where the impossible pred actually holds due to it also existing in this env.
+                    return Err(EvaluateConstErr::ImpossibleClauses);
                 }
 
                 let typing_env = infcx

compiler/rustc_trait_selection/src/traits/select/mod.rs

@@ -932,6 +932,12 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                                 Err(_) => Ok(EvaluatedToErr),
                             }
                         }
+                        (Err(EvaluateConstErr::ImpossibleClauses), _)
+                        | (_, Err(EvaluateConstErr::ImpossibleClauses)) => {
+                            unreachable!(
+                                "under gce constants shouldnt be wf checked before evaluating"
+                            )
+                        }
                         (Err(EvaluateConstErr::InvalidConstParamTy(..)), _)
                         | (_, Err(EvaluateConstErr::InvalidConstParamTy(..))) => Ok(EvaluatedToErr),
                         (Err(EvaluateConstErr::EvaluationFailure(..)), _)

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;