WIP

BoxyUwU · BoxyUwU · commit ba7d9f321033 · 2025-03-12T12:57:32.000Z
diff --git a/compiler/rustc_codegen_cranelift/src/global_asm.rs b/compiler/rustc_codegen_cranelift/src/global_asm.rs
@@ -53,6 +53,12 @@ pub(crate) fn codegen_global_asm_item(tcx: TyCtxt<'_>, global_asm: &mut String,
                                 Err(ErrorHandled::TooGeneric(_)) => {
                                     span_bug!(op_sp, "asm const cannot be resolved; too generic");
                                 }
+                                Err(ErrorHandled::ImpossiblePreds(_)) => {
+                                    span_bug!(
+                                        op_sp,
+                                        "constant value failed to evaluate due to trivial bounds",
+                                    );
+                                }
                             }
                         }
                         InlineAsmOperand::SymFn { expr } => {
diff --git a/compiler/rustc_codegen_ssa/src/mono_item.rs b/compiler/rustc_codegen_ssa/src/mono_item.rs
@@ -69,6 +69,12 @@ impl<'a, 'tcx: 'a> MonoItemExt<'a, 'tcx> for MonoItem<'tcx> {
                                             "asm const cannot be resolved; too generic"
                                         )
                                     }
+                                    Err(ErrorHandled::ImpossiblePreds(_)) => {
+                                        span_bug!(
+                                            *op_sp,
+                                            "asm const cannot be resolved; impossible preds"
+                                        )
+                                    }
                                 }
                             }
                             hir::InlineAsmOperand::SymFn { expr } => {
diff --git a/compiler/rustc_const_eval/src/const_eval/eval_queries.rs b/compiler/rustc_const_eval/src/const_eval/eval_queries.rs
@@ -335,6 +335,19 @@ 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.instantiate_and_check_impossible_predicates((instance_def, key.value.instance.args))
+        {
+            return Err(ErrorHandled::ImpossiblePreds(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()));
diff --git a/compiler/rustc_const_eval/src/interpret/eval_context.rs b/compiler/rustc_const_eval/src/interpret/eval_context.rs
@@ -544,7 +544,8 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
             let const_val = val.eval(*ecx.tcx, ecx.typing_env, span).map_err(|err| {
                 if M::ALL_CONSTS_ARE_PRECHECKED {
                     match err {
-                        ErrorHandled::TooGeneric(..) => {},
+                        ErrorHandled::TooGeneric(..)
+                        | ErrorHandled::ImpossiblePreds(..) => {}
                         ErrorHandled::Reported(reported, span) => {
                             if reported.is_allowed_in_infallible() {
                                 // These errors can just sometimes happen, even when the expression
diff --git a/compiler/rustc_hir_analysis/src/check/wfcheck.rs b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
@@ -1221,6 +1221,11 @@ fn check_type_defn<'tcx>(
                     Err(ErrorHandled::TooGeneric(sp)) => {
                         span_bug!(sp, "enum variant discr was too generic to eval")
                     }
+                    Err(ErrorHandled::ImpossiblePreds(sp)) => {
+                        _ = tcx
+                            .dcx()
+                            .span_err(sp, "constant value failed to evaluate due to trivial bounds")
+                    }
                 }
             }
         }
diff --git a/compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs b/compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs
@@ -429,6 +429,7 @@ provide! { tcx, def_id, other, cdata,
     doc_link_traits_in_scope => {
         tcx.arena.alloc_from_iter(cdata.get_doc_link_traits_in_scope(def_id.index))
     }
+    anon_const_kind => { table }
 }
 
 pub(in crate::rmeta) fn provide(providers: &mut Providers) {
diff --git a/compiler/rustc_middle/src/mir/interpret/error.rs b/compiler/rustc_middle/src/mir/interpret/error.rs
@@ -25,6 +25,7 @@ pub enum ErrorHandled {
     /// Don't emit an error, the evaluation failed because the MIR was generic
     /// and the args didn't fully monomorphize it.
     TooGeneric(Span),
+    ImpossiblePreds(Span),
 }
 
 impl From<ReportedErrorInfo> for ErrorHandled {
@@ -39,6 +40,7 @@ impl ErrorHandled {
         match self {
             ErrorHandled::Reported(err, _span) => ErrorHandled::Reported(err, span),
             ErrorHandled::TooGeneric(_span) => ErrorHandled::TooGeneric(span),
+            ErrorHandled::ImpossiblePreds(_span) => ErrorHandled::ImpossiblePreds(span),
         }
     }
 
@@ -49,7 +51,7 @@ impl ErrorHandled {
                     tcx.dcx().emit_note(error::ErroneousConstant { span });
                 }
             }
-            &ErrorHandled::TooGeneric(_) => {}
+            ErrorHandled::TooGeneric(_) | ErrorHandled::ImpossiblePreds(_) => {}
         }
     }
 }
@@ -188,7 +190,9 @@ impl From<ErrorHandled> for InterpErrorInfo<'_> {
     fn from(err: ErrorHandled) -> Self {
         InterpErrorKind::InvalidProgram(match err {
             ErrorHandled::Reported(r, _span) => InvalidProgramInfo::AlreadyReported(r),
-            ErrorHandled::TooGeneric(_span) => InvalidProgramInfo::TooGeneric,
+            ErrorHandled::TooGeneric(_span) | ErrorHandled::ImpossiblePreds(_span) => {
+                InvalidProgramInfo::TooGeneric
+            }
         })
         .into()
     }
diff --git a/compiler/rustc_middle/src/ty/adt.rs b/compiler/rustc_middle/src/ty/adt.rs
@@ -525,6 +525,10 @@ impl<'tcx> AdtDef<'tcx> {
             Err(err) => {
                 let guar = match err {
                     ErrorHandled::Reported(info, _) => info.into(),
+                    ErrorHandled::ImpossiblePreds(_span) => tcx.dcx().span_err(
+                        tcx.def_span(expr_did),
+                        "constant value failed to evaluate due to trivial bounds",
+                    ),
                     ErrorHandled::TooGeneric(..) => tcx.dcx().span_delayed_bug(
                         tcx.def_span(expr_did),
                         "enum discriminant depends on generics",
diff --git a/compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs b/compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs
@@ -139,7 +139,7 @@ impl<'tcx> ConstToPat<'tcx> {
                 }
                 return self.mk_err(err, ty);
             }
-            Err(ErrorHandled::TooGeneric(_)) => {
+            Err(ErrorHandled::ImpossiblePreds(_) | ErrorHandled::TooGeneric(_)) => {
                 let mut e = self
                     .tcx
                     .dcx()
diff --git a/compiler/rustc_monomorphize/src/collector.rs b/compiler/rustc_monomorphize/src/collector.rs
@@ -661,6 +661,11 @@ impl<'a, 'tcx> MirUsedCollector<'a, 'tcx> {
                 err.emit_note(self.tcx);
                 return None;
             }
+            Err(ErrorHandled::ImpossiblePreds(..)) => span_bug!(
+                constant.span,
+                "collection encountered constant with impossible preds: {:?}",
+                const_,
+            ),
         }
     }
 }
diff --git a/compiler/rustc_passes/src/reachable.rs b/compiler/rustc_passes/src/reachable.rs
@@ -219,7 +219,9 @@ impl<'tcx> ReachableContext<'tcx> {
                             // We can't figure out which value the constant will evaluate to. In
                             // lieu of that, we have to consider everything mentioned in the const
                             // initializer reachable, since it *may* end up in the final value.
-                            Err(ErrorHandled::TooGeneric(_)) => self.visit_nested_body(init),
+                            Err(ErrorHandled::TooGeneric(_) | ErrorHandled::ImpossiblePreds(_)) => {
+                                self.visit_nested_body(init)
+                            }
                             // If there was an error evaluating the const, nothing can be reachable
                             // via it, and anyway compilation will fail.
                             Err(ErrorHandled::Reported(..)) => {}
diff --git a/compiler/rustc_smir/src/rustc_smir/builder.rs b/compiler/rustc_smir/src/rustc_smir/builder.rs
@@ -63,7 +63,10 @@ impl<'tcx> MutVisitor<'tcx> for BodyBuilder<'tcx> {
         let val = match const_.eval(self.tcx, ty::TypingEnv::fully_monomorphized(), constant.span) {
             Ok(v) => v,
             Err(mir::interpret::ErrorHandled::Reported(..)) => return,
-            Err(mir::interpret::ErrorHandled::TooGeneric(..)) => {
+            Err(
+                mir::interpret::ErrorHandled::ImpossiblePreds(..)
+                | mir::interpret::ErrorHandled::TooGeneric(..),
+            ) => {
                 unreachable!("Failed to evaluate instance constant: {:?}", const_)
             }
         };
diff --git a/compiler/rustc_trait_selection/src/traits/const_evaluatable.rs b/compiler/rustc_trait_selection/src/traits/const_evaluatable.rs
@@ -154,12 +154,7 @@ 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::ImpossibleClauses) => Ok(()),
             Err(
                 EvaluateConstErr::EvaluationFailure(e) | EvaluateConstErr::InvalidConstParamTy(e),
             ) => Err(NotConstEvaluatable::Error(e)),
diff --git a/compiler/rustc_trait_selection/src/traits/mod.rs b/compiler/rustc_trait_selection/src/traits/mod.rs
@@ -561,7 +561,9 @@ pub fn try_evaluate_const<'tcx>(
             //
             // FIXME: `const_eval_resolve_for_typeck` should probably just modify the env itself
             // instead of having this logic here
-            let (args, typing_env) = if tcx.features().generic_const_exprs() {
+            let (args, typing_env) = if tcx.def_kind(uv.def) == DefKind::AnonConst
+                && let ty::AnonConstKind::GCEConst = tcx.anon_const_kind(uv.def)
+            {
                 // 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.
@@ -603,11 +605,8 @@ pub fn try_evaluate_const<'tcx>(
                         .with_post_analysis_normalized(tcx);
                     (uv.args, typing_env)
                 }
-            } else if !tcx.features().min_generic_const_args()
-                && !tcx.features().associated_const_equality()
-                // We check for anon consts so that when `associated_const_equality` bounds are
-                // lowered on stable we still handle them correctly to avoid ICEs in CTFE.
-                && tcx.def_kind(uv.def) == DefKind::AnonConst
+            } else if tcx.def_kind(uv.def) == DefKind::AnonConst
+                && let ty::AnonConstKind::RepeatExprCount = tcx.anon_const_kind(uv.def)
             {
                 // FIXME: remove this when `const_evaluatable_unchecked` is a hard error.
                 //
@@ -636,8 +635,8 @@ 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.
+                // We FCW repeat exprs that depend on impossible preds as they will no longer typecheck
+                // once they stop inheriting their parents predicates.
                 if tcx
                     .instantiate_and_check_impossible_predicates((uv.def, tcx.erase_regions(args)))
                 {
@@ -653,10 +652,8 @@ pub fn try_evaluate_const<'tcx>(
                             },
                         )
                     } 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.
+                        // If the anon const is non local then it should have been FCW'd in the upstream
+                        // crate. So we don't care.
                     }
                 };
 
@@ -666,30 +663,12 @@ pub fn try_evaluate_const<'tcx>(
                 // - `generic_const_exprs` has been handled separately in the first if
                 // - `min_const_generics` repeat expr count hacks have been handled in the previous if
                 //
-                // So we are free to simply defer evaluation here. This does assume that `uv.args` has
-                // already been normalized.
+                // So we are free to simply defer evaluation here.
+                // FIXME: This assumes the args are already normalized
                 if uv.args.has_non_region_param() || uv.args.has_non_region_infer() {
                     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);
@@ -716,6 +695,7 @@ pub fn try_evaluate_const<'tcx>(
                     Err(EvaluateConstErr::EvaluationFailure(info.into()))
                 }
                 Err(ErrorHandled::TooGeneric(_)) => Err(EvaluateConstErr::HasGenericsOrInfers),
+                Err(ErrorHandled::ImpossiblePreds(_)) => Err(EvaluateConstErr::ImpossibleClauses),
             }
         }
     }

Original file line number	Diff line number	Diff line change
`@@ -53,6 +53,12 @@ pub(crate) fn codegen_global_asm_item(tcx: TyCtxt<'_>, global_asm: &mut String,`
`53`	`53`	`Err(ErrorHandled::TooGeneric(_)) => {`
`54`	`54`	`span_bug!(op_sp, "asm const cannot be resolved; too generic");`
`55`	`55`	`}`
	`56`	`+ Err(ErrorHandled::ImpossiblePreds(_)) => {`
	`57`	`+ span_bug!(`
	`58`	`+ op_sp,`
	`59`	`+ "constant value failed to evaluate due to trivial bounds",`
	`60`	`+ );`
	`61`	`+ }`
`56`	`62`	`}`
`57`	`63`	`}`
`58`	`64`	`InlineAsmOperand::SymFn { expr } => {`
Original file line number	Diff line number	Diff line change
`@@ -69,6 +69,12 @@ impl<'a, 'tcx: 'a> MonoItemExt<'a, 'tcx> for MonoItem<'tcx> {`
`69`	`69`	`"asm const cannot be resolved; too generic"`
`70`	`70`	`)`
`71`	`71`	`}`
	`72`	`+ Err(ErrorHandled::ImpossiblePreds(_)) => {`
	`73`	`+ span_bug!(`
	`74`	`+ *op_sp,`
	`75`	`+ "asm const cannot be resolved; impossible preds"`
	`76`	`+ )`
	`77`	`+ }`
`72`	`78`	`}`
`73`	`79`	`}`
`74`	`80`	`hir::InlineAsmOperand::SymFn { expr } => {`
Original file line number	Diff line number	Diff line change
`@@ -1221,6 +1221,11 @@ fn check_type_defn<'tcx>(`
`1221`	`1221`	`Err(ErrorHandled::TooGeneric(sp)) => {`
`1222`	`1222`	`span_bug!(sp, "enum variant discr was too generic to eval")`
`1223`	`1223`	`}`
	`1224`	`+ Err(ErrorHandled::ImpossiblePreds(sp)) => {`
	`1225`	`+ _ = tcx`
	`1226`	`+ .dcx()`
	`1227`	`+ .span_err(sp, "constant value failed to evaluate due to trivial bounds")`
	`1228`	`+ }`
`1224`	`1229`	`}`
`1225`	`1230`	`}`
`1226`	`1231`	`}`
Original file line number	Diff line number	Diff line change
`@@ -429,6 +429,7 @@ provide! { tcx, def_id, other, cdata,`
`429`	`429`	`doc_link_traits_in_scope => {`
`430`	`430`	`tcx.arena.alloc_from_iter(cdata.get_doc_link_traits_in_scope(def_id.index))`
`431`	`431`	`}`
	`432`	`+ anon_const_kind => { table }`
`432`	`433`	`}`
`433`	`434`
`434`	`435`	`pub(in crate::rmeta) fn provide(providers: &mut Providers) {`
Original file line number	Diff line number	Diff line change
`@@ -25,6 +25,7 @@ pub enum ErrorHandled {`
`25`	`25`	`/// Don't emit an error, the evaluation failed because the MIR was generic`
`26`	`26`	`/// and the args didn't fully monomorphize it.`
`27`	`27`	`TooGeneric(Span),`
	`28`	`+ ImpossiblePreds(Span),`
`28`	`29`	`}`
`29`	`30`
`30`	`31`	`impl From<ReportedErrorInfo> for ErrorHandled {`
`@@ -39,6 +40,7 @@ impl ErrorHandled {`
`39`	`40`	`match self {`
`40`	`41`	`ErrorHandled::Reported(err, _span) => ErrorHandled::Reported(err, span),`
`41`	`42`	`ErrorHandled::TooGeneric(_span) => ErrorHandled::TooGeneric(span),`
	`43`	`+ ErrorHandled::ImpossiblePreds(_span) => ErrorHandled::ImpossiblePreds(span),`
`42`	`44`	`}`
`43`	`45`	`}`
`44`	`46`
`@@ -49,7 +51,7 @@ impl ErrorHandled {`
`49`	`51`	`tcx.dcx().emit_note(error::ErroneousConstant { span });`
`50`	`52`	`}`
`51`	`53`	`}`
`52`		`- &ErrorHandled::TooGeneric(_) => {}`
	`54`	`+ ErrorHandled::TooGeneric(_) \| ErrorHandled::ImpossiblePreds(_) => {}`
`53`	`55`	`}`
`54`	`56`	`}`
`55`	`57`	`}`
`@@ -188,7 +190,9 @@ impl From<ErrorHandled> for InterpErrorInfo<'_> {`
`188`	`190`	`fn from(err: ErrorHandled) -> Self {`
`189`	`191`	`InterpErrorKind::InvalidProgram(match err {`
`190`	`192`	`ErrorHandled::Reported(r, _span) => InvalidProgramInfo::AlreadyReported(r),`
`191`		`- ErrorHandled::TooGeneric(_span) => InvalidProgramInfo::TooGeneric,`
	`193`	`+ ErrorHandled::TooGeneric(_span) \| ErrorHandled::ImpossiblePreds(_span) => {`
	`194`	`+ InvalidProgramInfo::TooGeneric`
	`195`	`+ }`
`192`	`196`	`})`
`193`	`197`	`.into()`
`194`	`198`	`}`
Original file line number	Diff line number	Diff line change
`@@ -139,7 +139,7 @@ impl<'tcx> ConstToPat<'tcx> {`
`139`	`139`	`}`
`140`	`140`	`return self.mk_err(err, ty);`
`141`	`141`	`}`
`142`		`- Err(ErrorHandled::TooGeneric(_)) => {`
	`142`	`+ Err(ErrorHandled::ImpossiblePreds(_) \| ErrorHandled::TooGeneric(_)) => {`
`143`	`143`	`let mut e = self`
`144`	`144`	`.tcx`
`145`	`145`	`.dcx()`
Original file line number	Diff line number	Diff line change
`@@ -661,6 +661,11 @@ impl<'a, 'tcx> MirUsedCollector<'a, 'tcx> {`
`661`	`661`	`err.emit_note(self.tcx);`
`662`	`662`	`return None;`
`663`	`663`	`}`
	`664`	`+ Err(ErrorHandled::ImpossiblePreds(..)) => span_bug!(`
	`665`	`+ constant.span,`
	`666`	`+ "collection encountered constant with impossible preds: {:?}",`
	`667`	`+ const_,`
	`668`	`+ ),`
`664`	`669`	`}`
`665`	`670`	`}`
`666`	`671`	`}`