turn new resolving behavior on unconditionally

Author: fee1-dead

compiler/rustc_const_eval/src/interpret/eval_context.rs

@@ -370,7 +370,10 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
         trace!("resolve: {:?}, {:#?}", def, args);
         trace!("typing_env: {:#?}", self.typing_env);
         trace!("args: {:#?}", args);
-        let resolve = if M::SHOULD_RESPECT_CONST_BOUNDS_WHEN_RESOLVING_INSTANCES {
+
+        let resolve = if M::SHOULD_RESPECT_CONST_BOUNDS_WHEN_RESOLVING_INSTANCES
+            && !self.tcx.sess.opts.unstable_opts.unleash_the_miri_inside_of_you
+        {
             ty::Instance::try_resolve_for_ctfe
         } else {
             ty::Instance::try_resolve

compiler/rustc_traits/src/codegen.rs

@@ -23,7 +23,7 @@ use tracing::debug;
 ///
 /// This also expects that `trait_ref` is fully normalized.
 ///
-/// When `use_const` is set, we assume the new trait solver is enabled and use
+/// When `use_const` is set, we use the new trait solver to prove
 /// `HostEffectPredicate` with `constness` set to `Const`.
 pub(crate) fn codegen_select_candidate_inner<'tcx>(
     tcx: TyCtxt<'tcx>,
@@ -36,7 +36,13 @@ pub(crate) fn codegen_select_candidate_inner<'tcx>(
 
     // Do the initial selection for the obligation. This yields the
     // shallow result we are looking for -- that is, what specific impl.
-    let (infcx, param_env) = tcx.infer_ctxt().ignoring_regions().build_with_typing_env(typing_env);
+    let mut infcx_builder = tcx.infer_ctxt().ignoring_regions();
+    if use_const {
+        // next trait solver is used unconditionally here, because only const code that use trait methods
+        // are effected (nightly code)
+        infcx_builder = infcx_builder.with_next_trait_solver(true);
+    }
+    let (infcx, param_env) = infcx_builder.build_with_typing_env(typing_env);
     let mut selcx = SelectionContext::new(&infcx);
 
     let obligation_cause = ObligationCause::dummy();
@@ -45,7 +51,6 @@ pub(crate) fn codegen_select_candidate_inner<'tcx>(
         let host_predicate =
             ty::HostEffectPredicate { trait_ref, constness: ty::BoundConstness::Const };
         let obligation = Obligation::new(tcx, obligation_cause, param_env, host_predicate);
-
         infcx.select_host_effect_predicate_in_new_trait_solver(&obligation)
     } else {
         let obligation = Obligation::new(tcx, obligation_cause, param_env, trait_ref);

compiler/rustc_ty_utils/src/instance.rs

@@ -114,7 +114,7 @@ fn resolve_associated_item<'tcx>(
     let trait_ref = ty::TraitRef::from_assoc(tcx, trait_id, rcvr_args);
 
     let input = typing_env.as_query_input(trait_ref);
-    let candidate = if constness == Constness::Const && tcx.next_trait_solver_globally() {
+    let candidate = if constness == Constness::Const {
         tcx.codegen_select_candidate_for_ctfe(input)
     } else {
         tcx.codegen_select_candidate(input)

tests/ui/consts/qualif-indirect-mutation-fail.rs

@@ -15,7 +15,7 @@ pub const A1: () = {
     let b = &mut y;
     std::mem::swap(a, b);
     std::mem::forget(y);
-}; //~ ERROR calling non-const function `<Vec<u8> as Drop>::drop`
+};
 
 // Mutable borrow of a type with drop impl.
 pub const A2: () = {
@@ -26,7 +26,7 @@ pub const A2: () = {
     std::mem::swap(a, b);
     std::mem::forget(y);
     let _z = x; //~ ERROR destructor of
-}; //~ ERROR calling non-const function `<Vec<u8> as Drop>::drop`
+};
 
 // Shared borrow of a type that might be !Freeze and Drop.
 pub const fn g1<T>() {

tests/ui/consts/qualif-indirect-mutation-fail.stderr

@@ -7,19 +7,6 @@ LL |     let mut x = None;
 LL | };
    | - value is dropped here
 
-error[E0080]: calling non-const function `<Vec<u8> as Drop>::drop`
-  --> $DIR/qualif-indirect-mutation-fail.rs:18:1
-   |
-LL | };
-   | ^ evaluation of `A1` failed inside this call
-   |
-note: inside `std::ptr::drop_glue::<Option<String>> - shim(Some(Option<String>))`
-  --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
-note: inside `std::ptr::drop_glue::<String> - shim(Some(String))`
-  --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
-note: inside `std::ptr::drop_glue::<Vec<u8>> - shim(Some(Vec<u8>))`
-  --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
-
 error[E0493]: destructor of `Option<String>` cannot be evaluated at compile-time
   --> $DIR/qualif-indirect-mutation-fail.rs:28:9
    |
@@ -28,19 +15,6 @@ LL |     let _z = x;
 LL | };
    | - value is dropped here
 
-error[E0080]: calling non-const function `<Vec<u8> as Drop>::drop`
-  --> $DIR/qualif-indirect-mutation-fail.rs:29:1
-   |
-LL | };
-   | ^ evaluation of `A2` failed inside this call
-   |
-note: inside `std::ptr::drop_glue::<Option<String>> - shim(Some(Option<String>))`
-  --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
-note: inside `std::ptr::drop_glue::<String> - shim(Some(String))`
-  --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
-note: inside `std::ptr::drop_glue::<Vec<u8>> - shim(Some(Vec<u8>))`
-  --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
-
 error[E0493]: destructor of `(u32, Option<String>)` cannot be evaluated at compile-time
   --> $DIR/qualif-indirect-mutation-fail.rs:6:9
    |
@@ -103,7 +77,6 @@ LL |     let x: Option<String> = None;
 LL | }
    | - value is dropped here
 
-error: aborting due to 11 previous errors
+error: aborting due to 9 previous errors
 
-Some errors have detailed explanations: E0080, E0493.
-For more information about an error, try `rustc --explain E0080`.
+For more information about this error, try `rustc --explain E0493`.