-Znext-solver Ignore region constraints from the nested goals in leakcheck

compiler/rustc_borrowck/src/type_check/constraint_conversion.rs

@@ -74,7 +74,7 @@ impl<'a, 'tcx> ConstraintConversion<'a, 'tcx> {
         let assumptions =
             elaborate::elaborate_outlives_assumptions(self.infcx.tcx, assumptions.iter().copied());
 
-        for &(constraint, constraint_category) in constraints {
+        for &(constraint, constraint_category, _) in constraints {
             constraint.iter_outlives().for_each(|predicate| {
                 self.convert(predicate, constraint_category, &assumptions);
             });
@@ -296,7 +296,7 @@ impl<'a, 'tcx> ConstraintConversion<'a, 'tcx> {
                 // FIXME(higher_ranked_auto): What should we do with the assumptions here?
                 if let Some(QueryRegionConstraints { constraints, assumptions: _ }) = constraints {
                     next_outlives_predicates.extend(constraints.iter().flat_map(
-                        |(constraint, category)| {
+                        |(constraint, category, _)| {
                             constraint.iter_outlives().map(|outlives| (outlives, *category))
                         },
                     ));

compiler/rustc_hir_analysis/src/check/wfcheck.rs

@@ -728,6 +728,7 @@ fn region_known_to_outlive<'tcx>(
             SubregionOrigin::RelateRegionParamBound(DUMMY_SP, None),
             region_b,
             region_a,
+            ty::VisibleForLeakCheck::Unreachable,
         );
     })
 }

compiler/rustc_hir_analysis/src/coherence/builtin.rs

@@ -496,7 +496,12 @@ pub(crate) fn coerce_unsized_info<'tcx>(
         }
 
         (&ty::Ref(r_a, ty_a, mutbl_a), &ty::Ref(r_b, ty_b, mutbl_b)) => {
-            infcx.sub_regions(SubregionOrigin::RelateObjectBound(span), r_b, r_a);
+            infcx.sub_regions(
+                SubregionOrigin::RelateObjectBound(span),
+                r_b,
+                r_a,
+                ty::VisibleForLeakCheck::Yes,
+            );
             let mt_a = ty::TypeAndMut { ty: ty_a, mutbl: mutbl_a };
             let mt_b = ty::TypeAndMut { ty: ty_b, mutbl: mutbl_b };
             check_mutbl(mt_a, mt_b, &|ty| Ty::new_imm_ref(tcx, r_b, ty))

compiler/rustc_infer/src/infer/canonical/query_response.rs

@@ -188,14 +188,14 @@ impl<'tcx> InferCtxt<'tcx> {
         let InferOk { value: result_args, obligations } =
             self.query_response_instantiation(cause, param_env, original_values, query_response)?;
 
-        for (constraint, _category) in &query_response.value.region_constraints.constraints {
+        for (constraint, _category, vis) in &query_response.value.region_constraints.constraints {
             let constraint = instantiate_value(self.tcx, &result_args, *constraint);
             match constraint {
                 ty::RegionConstraint::Outlives(predicate) => {
-                    self.register_outlives_constraint(predicate, cause);
+                    self.register_outlives_constraint(predicate, *vis, cause);
                 }
                 ty::RegionConstraint::Eq(predicate) => {
-                    self.register_region_eq_constraint(predicate, cause);
+                    self.register_region_eq_constraint(predicate, *vis, cause);
                 }
             }
         }
@@ -288,6 +288,7 @@ impl<'tcx> InferCtxt<'tcx> {
                         output_query_region_constraints.constraints.push((
                             ty::RegionEqPredicate(v_o.into(), v_r).into(),
                             constraint_category,
+                            ty::VisibleForLeakCheck::Yes,
                         ));
                     }
                 }
@@ -586,6 +587,7 @@ impl<'tcx> InferCtxt<'tcx> {
                         SubregionOrigin::RelateRegionParamBound(cause.span, None),
                         v1,
                         v2,
+                        ty::VisibleForLeakCheck::Yes,
                     );
                 }
                 (GenericArgKind::Const(v1), GenericArgKind::Const(v2)) => {
@@ -623,20 +625,24 @@ pub fn make_query_region_constraints<'tcx>(
             | ConstraintKind::RegSubReg => {
                 // Swap regions because we are going from sub (<=) to outlives (>=).
                 let constraint = ty::OutlivesPredicate(c.sup.into(), c.sub).into();
-                (constraint, origin.to_constraint_category())
+                (constraint, origin.to_constraint_category(), c.visible_for_leak_check)
             }
 
             ConstraintKind::VarEqVar | ConstraintKind::VarEqReg | ConstraintKind::RegEqReg => {
                 let constraint = ty::RegionEqPredicate(c.sup, c.sub).into();
-                (constraint, origin.to_constraint_category())
+                (constraint, origin.to_constraint_category(), c.visible_for_leak_check)
             }
         })
-        .chain(outlives_obligations.into_iter().map(|obl| {
-            (
-                ty::OutlivesPredicate(obl.sup_type.into(), obl.sub_region).into(),
-                obl.origin.to_constraint_category(),
-            )
-        }))
+        .chain(outlives_obligations.into_iter().map(
+            |TypeOutlivesConstraint { sub_region, sup_type, origin }| {
+                (
+                    ty::OutlivesPredicate(sup_type.into(), sub_region).into(),
+                    origin.to_constraint_category(),
+                    // We don't do leak checks for type outlives
+                    ty::VisibleForLeakCheck::Unreachable,
+                )
+            },
+        ))
         .collect();
 
     QueryRegionConstraints { constraints, assumptions }

compiler/rustc_infer/src/infer/context.rs

@@ -256,19 +256,33 @@ impl<'tcx> rustc_type_ir::InferCtxtLike for InferCtxt<'tcx> {
         self.probe(|_| probe())
     }
 
-    fn sub_regions(&self, sub: ty::Region<'tcx>, sup: ty::Region<'tcx>, span: Span) {
+    fn sub_regions(
+        &self,
+        sub: ty::Region<'tcx>,
+        sup: ty::Region<'tcx>,
+        vis: ty::VisibleForLeakCheck,
+        span: Span,
+    ) {
         self.inner.borrow_mut().unwrap_region_constraints().make_subregion(
             SubregionOrigin::RelateRegionParamBound(span, None),
             sub,
             sup,
+            vis,
         );
     }
 
-    fn equate_regions(&self, a: ty::Region<'tcx>, b: ty::Region<'tcx>, span: Span) {
+    fn equate_regions(
+        &self,
+        a: ty::Region<'tcx>,
+        b: ty::Region<'tcx>,
+        vis: ty::VisibleForLeakCheck,
+        span: Span,
+    ) {
         self.inner.borrow_mut().unwrap_region_constraints().make_eqregion(
             SubregionOrigin::RelateRegionParamBound(span, None),
             a,
             b,
+            vis,
         );
     }
 

compiler/rustc_infer/src/infer/lexical_region_resolve/mod.rs

@@ -149,7 +149,11 @@ impl<'cx, 'tcx> LexicalResolver<'cx, 'tcx> {
 
         // Deduplicating constraints is shown to have a positive perf impact.
         let mut seen = UnordSet::default();
-        self.data.constraints.retain(|(constraint, _)| seen.insert(*constraint));
+        self.data.constraints.retain_mut(|(constraint, _)| {
+            // We don't want to discern constraints by leak check visibility here
+            constraint.visible_for_leak_check = ty::VisibleForLeakCheck::Unreachable;
+            seen.insert(*constraint)
+        });
 
         if cfg!(debug_assertions) {
             self.dump_constraints();

compiler/rustc_infer/src/infer/mod.rs

@@ -698,8 +698,9 @@ impl<'tcx> InferCtxt<'tcx> {
         origin: SubregionOrigin<'tcx>,
         a: ty::Region<'tcx>,
         b: ty::Region<'tcx>,
+        vis: ty::VisibleForLeakCheck,
     ) {
-        self.inner.borrow_mut().unwrap_region_constraints().make_subregion(origin, a, b);
+        self.inner.borrow_mut().unwrap_region_constraints().make_subregion(origin, a, b, vis);
     }
 
     #[instrument(skip(self), level = "debug")]
@@ -708,8 +709,9 @@ impl<'tcx> InferCtxt<'tcx> {
         origin: SubregionOrigin<'tcx>,
         a: ty::Region<'tcx>,
         b: ty::Region<'tcx>,
+        vis: ty::VisibleForLeakCheck,
     ) {
-        self.inner.borrow_mut().unwrap_region_constraints().make_eqregion(origin, a, b);
+        self.inner.borrow_mut().unwrap_region_constraints().make_eqregion(origin, a, b, vis);
     }
 
     /// Processes a `Coerce` predicate from the fulfillment context.

compiler/rustc_infer/src/infer/outlives/obligations.rs

@@ -85,11 +85,12 @@ impl<'tcx> InferCtxt<'tcx> {
     pub fn register_outlives_constraint(
         &self,
         ty::OutlivesPredicate(arg, r2): ty::ArgOutlivesPredicate<'tcx>,
+        vis: ty::VisibleForLeakCheck,
         cause: &ObligationCause<'tcx>,
     ) {
         match arg.kind() {
             ty::GenericArgKind::Lifetime(r1) => {
-                self.register_region_outlives_constraint(ty::OutlivesPredicate(r1, r2), cause);
+                self.register_region_outlives_constraint(ty::OutlivesPredicate(r1, r2), vis, cause);
             }
             ty::GenericArgKind::Type(ty1) => {
                 self.register_type_outlives_constraint(ty1, r2, cause);
@@ -101,24 +102,26 @@ impl<'tcx> InferCtxt<'tcx> {
     pub fn register_region_eq_constraint(
         &self,
         ty::RegionEqPredicate(r_a, r_b): ty::RegionEqPredicate<'tcx>,
+        vis: ty::VisibleForLeakCheck,
         cause: &ObligationCause<'tcx>,
     ) {
         let origin = SubregionOrigin::from_obligation_cause(cause, || {
             SubregionOrigin::RelateRegionParamBound(cause.span, None)
         });
-        self.equate_regions(origin, r_a, r_b);
+        self.equate_regions(origin, r_a, r_b, vis);
     }
 
     pub fn register_region_outlives_constraint(
         &self,
         ty::OutlivesPredicate(r_a, r_b): ty::RegionOutlivesPredicate<'tcx>,
+        vis: ty::VisibleForLeakCheck,
         cause: &ObligationCause<'tcx>,
     ) {
         let origin = SubregionOrigin::from_obligation_cause(cause, || {
             SubregionOrigin::RelateRegionParamBound(cause.span, None)
         });
         // `'a: 'b` ==> `'b <= 'a`
-        self.sub_regions(origin, r_b, r_a);
+        self.sub_regions(origin, r_b, r_a, vis);
     }
 
     /// Registers that the given region obligation must be resolved
@@ -577,7 +580,8 @@ impl<'cx, 'tcx> TypeOutlivesDelegate<'tcx> for &'cx InferCtxt<'tcx> {
         b: ty::Region<'tcx>,
         _constraint_category: ConstraintCategory<'tcx>,
     ) {
-        self.sub_regions(origin, a, b)
+        // We don't do leak check in borrowck
+        self.sub_regions(origin, a, b, ty::VisibleForLeakCheck::Unreachable)
     }
 
     fn push_verify(

compiler/rustc_infer/src/infer/region_constraints/leak_check.rs

@@ -392,10 +392,15 @@ impl<'tcx> MiniGraph<'tcx> {
             {
                 match undo_entry {
                     &AddConstraint(i) => {
-                        region_constraints.data().constraints[i]
-                            .0
-                            .iter_outlives()
-                            .for_each(|c| each_edge(c.sub, c.sup));
+                        region_constraints.data().constraints[i].0.iter_outlives().for_each(
+                            |Constraint { kind: _, sub, sup, visible_for_leak_check }| {
+                                match visible_for_leak_check {
+                                    ty::VisibleForLeakCheck::Yes => each_edge(sub, sup),
+                                    ty::VisibleForLeakCheck::No => {}
+                                    ty::VisibleForLeakCheck::Unreachable => unreachable!(),
+                                }
+                            },
+                        );
                     }
                     &AddVerify(i) => span_bug!(
                         region_constraints.data().verifys[i].origin.span(),
@@ -410,7 +415,13 @@ impl<'tcx> MiniGraph<'tcx> {
                 .constraints
                 .iter()
                 .flat_map(|(c, _)| c.iter_outlives())
-                .for_each(|c| each_edge(c.sub, c.sup))
+                .for_each(|Constraint { kind: _, sub, sup, visible_for_leak_check }| {
+                    match visible_for_leak_check {
+                        ty::VisibleForLeakCheck::Yes => each_edge(sub, sup),
+                        ty::VisibleForLeakCheck::No => {}
+                        ty::VisibleForLeakCheck::Unreachable => unreachable!(),
+                    }
+                })
         }
     }