Ensure constants are WF before calling into CTFE

Author: BoxyUwU

compiler/rustc_const_eval/src/check_consts/ops.rs

@@ -142,7 +142,7 @@ impl<'tcx> NonConstOp<'tcx> for FnCallNonConst<'tcx> {
             |err, self_ty, trait_id| {
                 // FIXME(const_trait_impl): Do we need any of this on the non-const codepath?
 
-                let trait_ref = TraitRef::from_method(tcx, trait_id, self.args);
+                let trait_ref = TraitRef::from_assoc_args(tcx, trait_id, self.args);
 
                 match self_ty.kind() {
                     Param(param_ty) => {

compiler/rustc_const_eval/src/interpret/call.rs

@@ -741,7 +741,8 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
         let tcx = *self.tcx;
 
         let trait_def_id = tcx.trait_of_item(def_id).unwrap();
-        let virtual_trait_ref = ty::TraitRef::from_method(tcx, trait_def_id, virtual_instance.args);
+        let virtual_trait_ref =
+            ty::TraitRef::from_assoc_args(tcx, trait_def_id, virtual_instance.args);
         let existential_trait_ref = ty::ExistentialTraitRef::erase_self_ty(tcx, virtual_trait_ref);
         let concrete_trait_ref = existential_trait_ref.with_self_ty(tcx, dyn_ty);
 

compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/transform.rs

@@ -343,7 +343,7 @@ pub(crate) fn transform_instance<'tcx>(
         let upcast_ty = match tcx.trait_of_item(def_id) {
             Some(trait_id) => trait_object_ty(
                 tcx,
-                ty::Binder::dummy(ty::TraitRef::from_method(tcx, trait_id, instance.args)),
+                ty::Binder::dummy(ty::TraitRef::from_assoc_args(tcx, trait_id, instance.args)),
             ),
             // drop_in_place won't have a defining trait, skip the upcast
             None => instance.args.type_at(0),
@@ -482,7 +482,7 @@ fn implemented_method<'tcx>(
         trait_method = trait_method_bound;
         method_id = instance.def_id();
         trait_id = tcx.trait_of_item(method_id)?;
-        trait_ref = ty::EarlyBinder::bind(TraitRef::from_method(tcx, trait_id, instance.args));
+        trait_ref = ty::EarlyBinder::bind(TraitRef::from_assoc_args(tcx, trait_id, instance.args));
         trait_id
     } else {
         return None;

compiler/rustc_trait_selection/src/traits/mod.rs

@@ -545,75 +545,137 @@ pub fn try_evaluate_const<'tcx>(
         | ty::ConstKind::Expr(_) => Err(EvaluateConstErr::HasGenericsOrInfers),
         ty::ConstKind::Unevaluated(uv) => {
             // Postpone evaluation of constants that depend on generic parameters or
-            // inference variables.
+            // inference variables. Also ensure that constants are wf before passing
+            // them onto CTFE.
             //
-            // 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).
             // As a result we always use a revealed env when resolving the instance to evaluate.
             //
             // 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()
-                && 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);
+            let (args, typing_env) = if tcx.features().generic_const_exprs() {
+                // 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.
+                //
+                // We don't bother trying to ensure GCE constants are WF before passing them to CTFE as it would cause
+                // query cycles on almost every single call to this function.
+
+                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 && uv.has_non_region_infer() {
+            } 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
+            {
                 // 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",
-                );
+                // Under `min_const_generics` the only place we can encounter generics in type system
+                // consts is for the `const_evaluatable_unchecked` future compat lint. We don't care
+                // to handle them in important ways (e.g. deferring evaluation) so we handle it separately.
+
+                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",
+                    );
+                }
 
+                // Generic arguments to anon consts in the type system are never meaningful under mcg,
+                // there either are no arguments or its a repeat count and the arguments must not be
+                // depended on for evaluation.
                 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:
+                // - `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.
+                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_expr`
+                //
+                // 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 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);
+                }
+
                 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(
@@ -697,7 +759,7 @@ fn replace_param_and_infer_args_with_placeholder<'tcx>(
     args.fold_with(&mut ReplaceParamAndInferWithPlaceholder { tcx, idx: 0 })
 }
 
-/// Normalizes the predicates and checks whether they hold in an empty environment. If this
+/// Normalizes the predicates and checks whether they hold in a given empty. If this
 /// returns true, then either normalize encountered an error or one of the predicates did not
 /// hold. Used when creating vtables to check for unsatisfiable methods. This should not be
 /// used during analysis.
@@ -738,7 +800,7 @@ fn instantiate_and_check_impossible_predicates<'tcx>(
     // Specifically check trait fulfillment to avoid an error when trying to resolve
     // associated items.
     if let Some(trait_def_id) = tcx.trait_of_item(key.0) {
-        let trait_ref = ty::TraitRef::from_method(tcx, trait_def_id, key.1);
+        let trait_ref = ty::TraitRef::from_assoc_args(tcx, trait_def_id, key.1);
         predicates.push(trait_ref.upcast(tcx));
     }
 

compiler/rustc_ty_utils/src/instance.rs

@@ -102,7 +102,7 @@ fn resolve_associated_item<'tcx>(
 ) -> Result<Option<Instance<'tcx>>, ErrorGuaranteed> {
     debug!(?trait_item_id, ?typing_env, ?trait_id, ?rcvr_args, "resolve_associated_item");
 
-    let trait_ref = ty::TraitRef::from_method(tcx, trait_id, rcvr_args);
+    let trait_ref = ty::TraitRef::from_assoc_args(tcx, trait_id, rcvr_args);
 
     let input = typing_env.as_query_input(trait_ref);
     let vtbl = match tcx.codegen_select_candidate(input) {
@@ -232,7 +232,7 @@ fn resolve_associated_item<'tcx>(
             Some(ty::Instance::new(leaf_def.item.def_id, args))
         }
         traits::ImplSource::Builtin(BuiltinImplSource::Object(_), _) => {
-            let trait_ref = ty::TraitRef::from_method(tcx, trait_id, rcvr_args);
+            let trait_ref = ty::TraitRef::from_assoc_args(tcx, trait_id, rcvr_args);
             if trait_ref.has_non_region_infer() || trait_ref.has_non_region_param() {
                 // We only resolve totally substituted vtable entries.
                 None

compiler/rustc_type_ir/src/predicate.rs

@@ -74,7 +74,7 @@ impl<I: Interner> TraitRef<I> {
         Self::new_from_args(interner, trait_def_id, args)
     }
 
-    pub fn from_method(interner: I, trait_id: I::DefId, args: I::GenericArgs) -> TraitRef<I> {
+    pub fn from_assoc_args(interner: I, trait_id: I::DefId, args: I::GenericArgs) -> TraitRef<I> {
         let generics = interner.generics_of(trait_id);
         TraitRef::new(interner, trait_id, args.iter().take(generics.count()))
     }