show env normalization differences under two solvers

Author: adwinwhite

compiler/rustc_trait_selection/src/solve/normalize.rs

@@ -217,7 +217,8 @@ where
     fn try_fold_const(&mut self, ct: ty::Const<'tcx>) -> Result<ty::Const<'tcx>, Self::Error> {
         let infcx = self.at.infcx;
         debug_assert_eq!(ct, infcx.shallow_resolve_const(ct));
-        if !ct.has_aliases() {
+        // FIXME: `generic_const_exprs` causes query cycle problem. Same as the old solver.
+        if !ct.has_aliases() || infcx.tcx.features().generic_const_exprs() {
             return Ok(ct);
         }
 

compiler/rustc_trait_selection/src/traits/mod.rs

@@ -257,6 +257,7 @@ fn do_normalize_predicates<'tcx>(
     predicates: Vec<ty::Clause<'tcx>>,
 ) -> Result<Vec<ty::Clause<'tcx>>, ErrorGuaranteed> {
     let span = cause.span;
+    let original_predicates = predicates.clone();
 
     // FIXME. We should really... do something with these region
     // obligations. But this call just continues the older
@@ -283,6 +284,38 @@ fn do_normalize_predicates<'tcx>(
 
     debug!("do_normalize_predicates: normalized predicates = {:?}", predicates);
 
+    // The next solver returns nothing for values that contains type error.
+    // And type error should cause failure later. So we skip the consistency check.
+    if !tcx.next_trait_solver_globally() && !predicates.references_error() {
+        let infcx = tcx
+            .infer_ctxt()
+            .with_next_trait_solver(true)
+            .ignoring_regions()
+            .build(TypingMode::non_body_analysis());
+        for (orig_pred, pred_by_old) in original_predicates.into_iter().zip(&predicates) {
+            let inconsistent_pred_by_next =
+                match crate::solve::deeply_normalize::<_, ScrubbedTraitError<'tcx>>(
+                    infcx.at(&cause, elaborated_env),
+                    orig_pred,
+                ) {
+                    Ok(pred_by_next) => {
+                        if pred_by_next == *pred_by_old {
+                            continue;
+                        }
+                        Some(pred_by_next)
+                    }
+                    Err(_) => None,
+                };
+            tcx.dcx().span_err(
+                span,
+                format!(
+                    "inconsistency during normalizing env `{:#?}`, old={:#?}, next={:#?}",
+                    orig_pred, pred_by_old, inconsistent_pred_by_next
+                ),
+            );
+        }
+    }
+
     // We can use the `elaborated_env` here; the region code only
     // cares about declarations like `'a: 'b`.
     // FIXME: It's very weird that we ignore region obligations but apparently