Use new solver in MIR validator subtyping checks

Author: compiler-errors

compiler/rustc_const_eval/src/interpret/eval_context.rs

@@ -357,7 +357,7 @@ pub(super) fn mir_assign_valid_types<'tcx>(
     // all normal lifetimes are erased, higher-ranked types with their
     // late-bound lifetimes are still around and can lead to type
     // differences.
-    if util::is_subtype(tcx, param_env, src.ty, dest.ty) {
+    if util::is_subtype(tcx, param_env, src.ty, dest.ty, tcx.next_trait_solver_globally()) {
         // Make sure the layout is equal, too -- just to be safe. Miri really
         // needs layout equality. For performance reason we skip this check when
         // the types are equal. Equal types *can* have different layouts when

compiler/rustc_const_eval/src/transform/validate.rs

@@ -540,7 +540,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
             return true;
         }
 
-        crate::util::is_subtype(self.tcx, self.param_env, src, dest)
+        crate::util::is_subtype(self.tcx, self.param_env, src, dest, true)
     }
 }
 

compiler/rustc_const_eval/src/util/compare_types.rs

@@ -17,14 +17,16 @@ pub fn is_equal_up_to_subtyping<'tcx>(
     param_env: ParamEnv<'tcx>,
     src: Ty<'tcx>,
     dest: Ty<'tcx>,
+    next_trait_solver: bool,
 ) -> bool {
     // Fast path.
     if src == dest {
         return true;
     }
 
     // Check for subtyping in either direction.
-    is_subtype(tcx, param_env, src, dest) || is_subtype(tcx, param_env, dest, src)
+    is_subtype(tcx, param_env, src, dest, next_trait_solver)
+        || is_subtype(tcx, param_env, dest, src, next_trait_solver)
 }
 
 /// Returns whether `src` is a subtype of `dest`, i.e. `src <: dest`.
@@ -36,13 +38,17 @@ pub fn is_subtype<'tcx>(
     param_env: ParamEnv<'tcx>,
     src: Ty<'tcx>,
     dest: Ty<'tcx>,
+    next_trait_solver: bool,
 ) -> bool {
     if src == dest {
         return true;
     }
 
-    let mut builder =
-        tcx.infer_ctxt().ignoring_regions().with_opaque_type_inference(DefiningAnchor::Bubble);
+    let mut builder = tcx
+        .infer_ctxt()
+        .ignoring_regions()
+        .with_next_trait_solver(next_trait_solver)
+        .with_opaque_type_inference(DefiningAnchor::Bubble);
     let infcx = builder.build();
     let ocx = ObligationCtxt::new(&infcx);
     let cause = ObligationCause::dummy();

compiler/rustc_mir_transform/src/inline.rs

@@ -218,7 +218,7 @@ impl<'tcx> Inliner<'tcx> {
         // Normally, this shouldn't be required, but trait normalization failure can create a
         // validation ICE.
         let output_type = callee_body.return_ty();
-        if !util::is_subtype(self.tcx, self.param_env, output_type, destination_ty) {
+        if !util::is_subtype(self.tcx, self.param_env, output_type, destination_ty, true) {
             trace!(?output_type, ?destination_ty);
             return Err("failed to normalize return type");
         }
@@ -248,7 +248,7 @@ impl<'tcx> Inliner<'tcx> {
                 self_arg_ty.into_iter().chain(arg_tuple_tys).zip(callee_body.args_iter())
             {
                 let input_type = callee_body.local_decls[input].ty;
-                if !util::is_subtype(self.tcx, self.param_env, input_type, arg_ty) {
+                if !util::is_subtype(self.tcx, self.param_env, input_type, arg_ty, true) {
                     trace!(?arg_ty, ?input_type);
                     return Err("failed to normalize tuple argument type");
                 }
@@ -257,7 +257,7 @@ impl<'tcx> Inliner<'tcx> {
             for (arg, input) in args.iter().zip(callee_body.args_iter()) {
                 let input_type = callee_body.local_decls[input].ty;
                 let arg_ty = arg.ty(&caller_body.local_decls, self.tcx);
-                if !util::is_subtype(self.tcx, self.param_env, input_type, arg_ty) {
+                if !util::is_subtype(self.tcx, self.param_env, input_type, arg_ty, true) {
                     trace!(?arg_ty, ?input_type);
                     return Err("failed to normalize argument type");
                 }

compiler/rustc_trait_selection/src/traits/engine.rs

@@ -36,9 +36,7 @@ impl<'tcx> TraitEngineExt<'tcx> for dyn TraitEngine<'tcx> {
             (TraitSolver::Classic, false) | (TraitSolver::NextCoherence, false) => {
                 Box::new(FulfillmentContext::new(infcx))
             }
-            (TraitSolver::Next | TraitSolver::NextCoherence, true) => {
-                Box::new(NextFulfillmentCtxt::new(infcx))
-            }
+            (_, true) => Box::new(NextFulfillmentCtxt::new(infcx)),
             _ => bug!(
                 "incompatible combination of -Ztrait-solver flag ({:?}) and InferCtxt::next_trait_solver ({:?})",
                 infcx.tcx.sess.opts.unstable_opts.trait_solver,