Make sure to scrape region constraints from deeply normalizing type outlives assumptions in borrowck

compiler/rustc_borrowck/src/type_check/free_region_relations.rs

@@ -5,13 +5,14 @@ use rustc_infer::infer::canonical::QueryRegionConstraints;
 use rustc_infer::infer::outlives::env::RegionBoundPairs;
 use rustc_infer::infer::region_constraints::GenericKind;
 use rustc_infer::infer::{InferCtxt, outlives};
+use rustc_infer::traits::ScrubbedTraitError;
 use rustc_middle::mir::ConstraintCategory;
 use rustc_middle::traits::ObligationCause;
 use rustc_middle::traits::query::OutlivesBound;
 use rustc_middle::ty::{self, RegionVid, Ty, TypeVisitableExt};
 use rustc_span::{ErrorGuaranteed, Span};
-use rustc_trait_selection::error_reporting::InferCtxtErrorExt;
-use rustc_trait_selection::solve::deeply_normalize;
+use rustc_trait_selection::solve::NoSolution;
+use rustc_trait_selection::traits::query::type_op::custom::CustomTypeOp;
 use rustc_trait_selection::traits::query::type_op::{self, TypeOp};
 use tracing::{debug, instrument};
 use type_op::TypeOpOutput;
@@ -233,16 +234,29 @@ impl<'tcx> UniversalRegionRelationsBuilder<'_, 'tcx> {
 
             // In the new solver, normalize the type-outlives obligation assumptions.
             if self.infcx.next_trait_solver() {
-                match deeply_normalize(
-                    self.infcx.at(&ObligationCause::misc(span, defining_ty_def_id), param_env),
-                    outlives,
-                ) {
-                    Ok(normalized_outlives) => {
-                        outlives = normalized_outlives;
-                    }
-                    Err(e) => {
-                        self.infcx.err_ctxt().report_fulfillment_errors(e);
-                    }
+                let Ok(TypeOpOutput {
+                    output: normalized_outlives,
+                    constraints: constraints_normalize,
+                    error_info: _,
+                }) = CustomTypeOp::new(
+                    |ocx| {
+                        ocx.deeply_normalize(
+                            &ObligationCause::dummy_with_span(span),
+                            self.param_env,
+                            outlives,
+                        )
+                        .map_err(|_: Vec<ScrubbedTraitError<'tcx>>| NoSolution)
+                    },
+                    "normalize type outlives obligation",
+                )
+                .fully_perform(self.infcx, span)
+                else {
+                    self.infcx.dcx().delayed_bug(format!("could not normalize {outlives:?}"));
+                    continue;
+                };
+                outlives = normalized_outlives;
+                if let Some(c) = constraints_normalize {
+                    constraints.push(c);
                 }
             }
 

tests/ui/traits/next-solver/known-type-outlives-has-constraints.rs

@@ -0,0 +1,13 @@
+//@ compile-flags: -Znext-solver
+//@ check-pass
+
+trait Norm {
+    type Out;
+}
+impl<'a, T: 'a> Norm for &'a T {
+    type Out = T;
+}
+
+fn hello<'a, T: 'a>() where <&'a T as Norm>::Out: 'a {}
+
+fn main() {}