a

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_middle/src/query/mod.rs

@@ -2374,18 +2374,6 @@ rustc_queries! {
         }
     }
 
-    query check_constant_safe_to_evaluate(
-        key: ty::CanonicalQueryInput<
-            TyCtxt<'tcx>,
-            ty::ParamEnvAnd<'tcx, ty::UnevaluatedConst<'tcx>>,
-        >
-    ) -> bool {
-        desc { |tcx|
-            "checking constant `{}` is safe to evaluate",
-            tcx.def_path_str(key.canonical.value.into_parts().1.def)
-        }
-    }
-
     query method_autoderef_steps(
         goal: CanonicalTyGoal<'tcx>
     ) -> MethodAutoderefStepsResult<'tcx> {

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

@@ -28,7 +28,6 @@ use std::ops::ControlFlow;
 
 use rustc_errors::ErrorGuaranteed;
 use rustc_hir::def::DefKind;
-use rustc_infer::infer::canonical::OriginalQueryValues;
 pub use rustc_infer::traits::*;
 use rustc_middle::query::Providers;
 use rustc_middle::span_bug;
@@ -646,13 +645,18 @@ pub fn try_evaluate_const<'tcx>(
                 // 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`
-                let input = infcx
-                    .canonicalize_query(param_env.and(uv), &mut OriginalQueryValues::default());
-                if !tcx.check_constant_safe_to_evaluate(input) {
-                    let e = tcx.dcx().delayed_bug(
-                        "Attempted to evaluate illformed constant but no error emitted",
-                    );
-                    return Err(EvaluateConstErr::EvaluationFailure(e));
+                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 trivial bounds are somewhat supported.
+                    // Emitting an error would be fine but feels weird as we allow the where clause to be
+                    // written.
+                    return Ok(ct);
                 }
 
                 let typing_env = infcx
@@ -747,50 +751,6 @@ fn replace_param_and_infer_args_with_placeholder<'tcx>(
     args.fold_with(&mut ReplaceParamAndInferWithPlaceholder { tcx, idx: 0 })
 }
 
-#[instrument(level = "debug", skip(tcx), ret)]
-fn check_constant_safe_to_evaluate<'tcx>(
-    tcx: TyCtxt<'tcx>,
-    input: ty::CanonicalQueryInput<TyCtxt<'tcx>, ty::ParamEnvAnd<'tcx, ty::UnevaluatedConst<'tcx>>>,
-) -> bool {
-    let (infcx, param_env_and, _) = tcx.infer_ctxt().build_with_canonical(DUMMY_SP, &input);
-    let (param_env, uv) = param_env_and.into_parts();
-
-    // We can't just register a wf goal for the constant as that would require evaluating the constant
-    // which would result in a query cycle.
-    let mut predicates = tcx.predicates_of(uv.def).instantiate(tcx, uv.args).predicates;
-
-    // Specifically check trait fulfillment to avoid an error when trying to resolve
-    // associated items.
-    if let Some(trait_def_id) = tcx.trait_of_item(uv.def) {
-        let trait_ref = ty::TraitRef::from_method(tcx, trait_def_id, uv.args);
-        predicates.push(trait_ref.upcast(tcx));
-    }
-
-    let ocx = ObligationCtxt::new(&infcx);
-    let predicates = ocx.normalize(&ObligationCause::dummy(), param_env, predicates);
-    for predicate in predicates {
-        let obligation = Obligation::new(tcx, ObligationCause::dummy(), param_env, predicate);
-        ocx.register_obligation(obligation);
-    }
-    let errors = ocx.select_all_or_error();
-
-    if !errors.is_empty() {
-        return false;
-    }
-
-    // Leak check for any higher-ranked trait mismatches.
-    // We only need to do this in the old solver, since the new solver already
-    // leak-checks.
-    if !infcx.next_trait_solver() && infcx.leak_check(ty::UniverseIndex::ROOT, None).is_err() {
-        return false;
-    }
-
-    // We don't check non-higher-ranked region constraints, but we don't need to as region
-    // constraints cant affect coherence and therefore result in overlapping impls in codegen/ctfe
-    // so it shouldn't matter to speculatively evaluate constants with failing region constraints.
-    true
-}
-
 /// 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
@@ -832,7 +792,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));
     }
 
@@ -934,7 +894,6 @@ pub fn provide(providers: &mut Providers) {
         specialization_enabled_in: specialize::specialization_enabled_in,
         instantiate_and_check_impossible_predicates,
         is_impossible_associated_item,
-        check_constant_safe_to_evaluate,
         ..*providers
     };
 }

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()))
     }

tests/ui/const-generics/associated_const_equality/wf_before_evaluate.rs

@@ -20,5 +20,5 @@ fn ice<const N: u64, T: Trait<C<N> = { N }>>(_: T) {}
 
 fn main() {
     ice::<128, _>(());
-    //~^ ERROR: the constant `128` is not of type `u32`
+    //~^ ERROR: type mismatch resolving `<() as Trait>::C<128> == 128`
 }

tests/ui/const-generics/associated_const_equality/wf_before_evaluate.stderr

@@ -10,17 +10,22 @@ note: required by a const generic parameter in `Trait::C`
 LL |     const C<const N: u32>: u32;
    |             ^^^^^^^^^^^^ required by this const generic parameter in `Trait::C`
 
-error: the constant `128` is not of type `u32`
-  --> $DIR/wf_before_evaluate.rs:22:5
+error[E0271]: type mismatch resolving `<() as Trait>::C<128> == 128`
+  --> $DIR/wf_before_evaluate.rs:22:19
    |
 LL |     ice::<128, _>(());
-   |     ^^^^^^^^^^^^^^^^^ expected `u32`, found `u64`
+   |     ------------- ^^ expected `128`, found `<() as Trait>::C::<128>`
+   |     |
+   |     required by a bound introduced by this call
    |
-note: required by a const generic parameter in `Trait::C`
-  --> $DIR/wf_before_evaluate.rs:11:13
+   = note: expected constant `128`
+              found constant `<() as Trait>::C::<128>`
+note: required by a bound in `ice`
+  --> $DIR/wf_before_evaluate.rs:18:31
    |
-LL |     const C<const N: u32>: u32;
-   |             ^^^^^^^^^^^^ required by this const generic parameter in `Trait::C`
+LL | fn ice<const N: u64, T: Trait<C<N> = { N }>>(_: T) {}
+   |                               ^^^^^^^^^^^^ required by this bound in `ice`
 
 error: aborting due to 2 previous errors
 
+For more information about this error, try `rustc --explain E0271`.