also fully resolve predicates from the next solver

Author: adwinwhite

compiler/rustc_trait_selection/src/traits/mod.rs

@@ -328,25 +328,52 @@ fn do_normalize_predicates<'tcx>(
             .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>>(
+        let predicates_by_next: Vec<Option<_>> = original_predicates
+            .iter()
+            .cloned()
+            .map(|p| {
+                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,
-                };
+                    p,
+                )
+                .ok()
+            })
+            .collect();
+
+        let errors = infcx.resolve_regions(cause.body_id, elaborated_env, []);
+        if !errors.is_empty() {
+            tcx.dcx().span_delayed_bug(
+                span,
+                format!(
+                    "failed region resolution while normalizing {elaborated_env:?}: {errors:?}"
+                ),
+            );
+        }
+
+        let predicates_by_next = match infcx.fully_resolve(predicates_by_next) {
+            Ok(predicates) => predicates,
+            Err(fixup_err) => {
+                span_bug!(
+                    span,
+                    "inference variables in normalized parameter environment: {}",
+                    fixup_err
+                );
+            }
+        };
+
+        for ((orig_pred, old_pred), next_pred) in
+            original_predicates.iter().zip(&predicates).zip(&predicates_by_next)
+        {
+            if let Some(next_pred) = next_pred
+                && next_pred == old_pred
+            {
+                continue;
+            }
             tcx.dcx().span_err(
                 span,
                 format!(
                     "inconsistency during normalizing env `{:#?}`, old={:#?}, next={:#?}",
-                    orig_pred, pred_by_old, inconsistent_pred_by_next
+                    orig_pred, old_pred, next_pred
                 ),
             );
         }