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

Author: compiler-errors

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;
@@ -229,24 +230,14 @@ impl<'tcx> UniversalRegionRelationsBuilder<'_, 'tcx> {
 letmut constraints = vec![];
 letmut known_type_outlives_obligations = vec![];
 for bound in param_env.caller_bounds(){
-letSome(mut outlives) = bound.as_type_outlives_clause()else{continue};
-
-// In the new solver, normalize the type-outlives obligation assumptions.
-ifself.infcx.next_trait_solver(){
-matchdeeply_normalize(
-self.infcx.at(&ObligationCause::misc(span, defining_ty_def_id), param_env),
+ifletSome(outlives) = bound.as_type_outlives_clause(){
+self.normalize_and_push_type_outlives_obligation(
  outlives,
-){
-Ok(normalized_outlives) => {
- outlives = normalized_outlives;
-}
-Err(e) => {
-self.infcx.err_ctxt().report_fulfillment_errors(e);
-}
-}
-}
-
- known_type_outlives_obligations.push(outlives);
+ span,
+&mut known_type_outlives_obligations,
+&mut constraints,
+);
+};
 }
 
 let unnormalized_input_output_tys = self
@@ -356,6 +347,44 @@ impl<'tcx> UniversalRegionRelationsBuilder<'_, 'tcx> {
 }
 }
 
+fnnormalize_and_push_type_outlives_obligation(
+&self,
+mutoutlives: ty::PolyTypeOutlivesPredicate<'tcx>,
+span:Span,
+known_type_outlives_obligations:&mutVec<ty::PolyTypeOutlivesPredicate<'tcx>>,
+constraints:&mutVec<&QueryRegionConstraints<'tcx>>,
+){
+// In the new solver, normalize the type-outlives obligation assumptions.
+ifself.infcx.next_trait_solver(){
+letOk(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:?}"));
+return;
+};
+ outlives = normalized_outlives;
+ifletSome(c) = constraints_normalize {
+ constraints.push(c);
+}
+}
+
+ known_type_outlives_obligations.push(outlives);
+}
+
 /// Update the type of a single local, which should represent
 /// either the return type of the MIR or one of its arguments. At
 /// the same time, compute and add any implied bounds that come

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

@@ -0,0 +1,13 @@
+//@ compile-flags: -Znext-solver
+//@ check-pass
+
+traitNorm{
+typeOut;
+}
+impl<'a,T:'a>Normfor&'aT{
+typeOut = T;
+}
+
+fnhello<'a,T:'a>()where <&'aTasNorm>::Out:'a{}
+
+fnmain(){}