Remove the ImpossibleClauses err variant

Author: BoxyUwU

compiler/rustc_const_eval/src/const_eval/eval_queries.rs

@@ -335,6 +335,44 @@ pub fn eval_to_allocation_raw_provider<'tcx>(
     tcx: TyCtxt<'tcx>,
     key: ty::PseudoCanonicalInput<'tcx, GlobalId<'tcx>>,
 ) -> ::rustc_middle::mir::interpret::EvalToAllocationRawResult<'tcx> {
+    // Avoid evaluating instances with impossible bounds required to hold as
+    // this can result in executing code that should never be executed.
+    let instance_def = key.value.instance.def_id();
+    if tcx.def_kind(instance_def) == DefKind::AnonConst
+        && let ty::AnonConstKind::GCEConst = tcx.anon_const_kind(instance_def)
+    { // ... do nothing for GCE anon consts as it would cycle
+    } else if tcx.def_kind(instance_def) == DefKind::AnonConst
+        && let ty::AnonConstKind::RepeatExprCount = tcx.anon_const_kind(instance_def)
+    {
+        // Instead of erroring when encountering a repeat expr hack const with impossible
+        // preds we just FCW, as anon consts are unnameable and this code *might* wind up
+        // supported one day if the anon const is a path expr.
+        if tcx.instantiate_and_check_impossible_predicates((
+            instance_def,
+            tcx.erase_regions(key.value.instance.args),
+        )) {
+            if let Some(local_def) = instance_def.as_local() {
+                tcx.node_span_lint(
+                    rustc_session::lint::builtin::CONST_EVALUATABLE_UNCHECKED,
+                    tcx.local_def_id_to_hir_id(local_def),
+                    tcx.def_span(instance_def),
+                    |lint| {
+                        lint.primary_message(
+                            "cannot use constants which depend on trivially-false where clauses",
+                        );
+                    },
+                )
+            } else {
+                // If the repeat expr count is from some upstream crate then we don't care to
+                // lint on it as it should have been linted on when compiling the upstream crate.
+            }
+        };
+    } else if tcx
+        .instantiate_and_check_impossible_predicates((instance_def, key.value.instance.args))
+    {
+        return Err(ErrorHandled::TooGeneric(tcx.def_span(instance_def)));
+    }
+
     // This shouldn't be used for statics, since statics are conceptually places,
     // not values -- so what we do here could break pointer identity.
     assert!(key.value.promoted.is_some() || !tcx.is_static(key.value.instance.def_id()));

compiler/rustc_trait_selection/src/solve/delegate.rs

@@ -85,9 +85,7 @@ 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::ImpossibleClauses
-                | EvaluateConstErr::InvalidConstParamTy(_)
-                | EvaluateConstErr::HasGenericsOrInfers,
+                EvaluateConstErr::InvalidConstParamTy(_) | EvaluateConstErr::HasGenericsOrInfers,
             ) => None,
         }
     }

compiler/rustc_trait_selection/src/traits/const_evaluatable.rs

@@ -76,9 +76,6 @@ 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),
@@ -154,12 +151,6 @@ 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,8 +687,7 @@ impl<'a, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'tcx> {
                                 }
                                 e @ Err(
                                     EvaluateConstErr::EvaluationFailure(_)
-                                    | EvaluateConstErr::InvalidConstParamTy(_)
-                                    | EvaluateConstErr::ImpossibleClauses,
+                                    | EvaluateConstErr::InvalidConstParamTy(_),
                                 ) => e,
                             }
                         } else {
@@ -716,10 +715,6 @@ 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

@@ -38,7 +38,6 @@ use rustc_middle::ty::{
     self, GenericArgs, GenericArgsRef, Ty, TyCtxt, TypeFolder, TypeSuperFoldable,
     TypeSuperVisitable, TypingMode, Upcast,
 };
-use rustc_session::lint;
 use rustc_span::def_id::DefId;
 use rustc_span::{DUMMY_SP, Span};
 use tracing::{debug, instrument};
@@ -493,10 +492,6 @@ 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
@@ -518,7 +513,7 @@ pub fn evaluate_const<'tcx>(
         Err(EvaluateConstErr::EvaluationFailure(e) | EvaluateConstErr::InvalidConstParamTy(e)) => {
             ty::Const::new_error(infcx.tcx, e)
         }
-        Err(EvaluateConstErr::ImpossibleClauses | EvaluateConstErr::HasGenericsOrInfers) => ct,
+        Err(EvaluateConstErr::HasGenericsOrInfers) => ct,
     }
 }
 
@@ -635,30 +630,6 @@ pub fn try_evaluate_const<'tcx>(
                 let args = GenericArgs::identity_for_item(tcx, uv.def);
                 let typing_env = ty::TypingEnv::post_analysis(tcx, uv.def);
 
-                // Instead of erroring when encountering a constant with impossible preds we just FCW, as
-                // it would be a breaking change.
-                if tcx
-                    .instantiate_and_check_impossible_predicates((uv.def, tcx.erase_regions(args)))
-                {
-                    if let Some(local_def) = uv.def.as_local() {
-                        tcx.node_span_lint(
-                            lint::builtin::CONST_EVALUATABLE_UNCHECKED,
-                            tcx.local_def_id_to_hir_id(local_def),
-                            tcx.def_span(uv.def),
-                            |lint| {
-                                lint.primary_message(
-                                    "cannot use constants which depend on trivially-false where clauses",
-                                );
-                            },
-                        )
-                    } else {
-                        // If the anon const is not a local def then it's probably a GCE const from some
-                        // upstream crate. We don't need to lint on that. It also shouldn't be possible
-                        // for an upstream crate to put a repeat expr count anon const into a signature
-                        // and have it *only* evaluated in a downstream crate.
-                    }
-                };
-
                 (args, typing_env)
             } else {
                 // We are only dealing with "truly" generic/uninferred constants here:
@@ -671,24 +642,6 @@ pub fn try_evaluate_const<'tcx>(
                     return Err(EvaluateConstErr::HasGenericsOrInfers);
                 }
 
-                // 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_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
-                // only an `unreachable` terminator which makes evaluating them incorrect even if the
-                // impossible pred is satsifiable in this environment.
-                if tcx.instantiate_and_check_impossible_predicates((
-                    uv.def,
-                    tcx.erase_regions(uv.args),
-                )) {
-                    // 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
                     .typing_env(tcx.erase_regions(param_env))
                     .with_post_analysis_normalized(tcx);

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

@@ -932,12 +932,6 @@ 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(..)), _)