propagate region error for every non-local lower bound

Author: LorrensP-2158466

compiler/rustc_borrowck/src/region_infer/mod.rs

@@ -1275,13 +1275,19 @@ impl<'tcx> RegionInferenceContext<'tcx> {
         shorter_fr: RegionVid,
         propagated_outlives_requirements: &mut Option<&mut Vec<ClosureOutlivesRequirement<'tcx>>>,
     ) -> RegionRelationCheckResult {
-        if let Some(propagated_outlives_requirements) = propagated_outlives_requirements
-            // Shrink `longer_fr` until we find a non-local region (if we do).
-            // We'll call it `fr-` -- it's ever so slightly smaller than
+        if let Some(propagated_outlives_requirements) = propagated_outlives_requirements {
+            // Shrink `longer_fr` until we find some non-local regions.
+            // We'll call them `longer_fr-` -- they are ever so slightly smaller than
             // `longer_fr`.
-            && let Some(fr_minus) = self.universal_region_relations.non_local_lower_bound(longer_fr)
-        {
-            debug!("try_propagate_universal_region_error: fr_minus={:?}", fr_minus);
+            let longer_fr_minus = self.universal_region_relations.non_local_lower_bounds(longer_fr);
+
+            debug!("try_propagate_universal_region_error: fr_minus={:?}", longer_fr_minus);
+
+            // If we don't find a any non-local regions, we should error out as there is nothing
+            // to propagate.
+            if longer_fr_minus.is_empty() {
+                return RegionRelationCheckResult::Error;
+            }
 
             let blame_constraint = self
                 .best_blame_constraint(longer_fr, NllRegionVariableOrigin::FreeRegion, shorter_fr)
@@ -1292,8 +1298,17 @@ impl<'tcx> RegionInferenceContext<'tcx> {
             // so slightly larger than `shorter_fr`.
             let shorter_fr_plus =
                 self.universal_region_relations.non_local_upper_bounds(shorter_fr);
+            debug!("try_propagate_universal_region_error: shorter_fr_plus={:?}", shorter_fr_plus);
 
-            // If any of the `shorter_fr+` regions are already outlived by `fr-`, we propagate only those.
+            // We then create constraints `longer_fr-: shorter_fr+` that may or may not be propagated (see below).
+            let mut constraints = vec![];
+            for fr_minus in longer_fr_minus {
+                for shorter_fr_plus in &shorter_fr_plus {
+                    constraints.push((fr_minus, *shorter_fr_plus));
+                }
+            }
+
+            // If any of the `shorter_fr+` regions are already outlived by `longer_fr-`, we propagate only those.
             // Otherwise, we might incorrectly reject valid code.
             //
             // Consider this example (`'b: 'a` == `a -> b`), where we try to propagate `'d: 'a`:
@@ -1304,20 +1319,26 @@ impl<'tcx> RegionInferenceContext<'tcx> {
             // Propagating `'d: 'b` is correct and should occur; `'d: 'c` is redundant because of `'d: 'b`
             // and could reject valid code.
             //
-            // So we filter `shorter_fr+` to regions already outlived by `fr-`, but if the filter yields an empty set,
+            // So we filter the constraints to regions already outlived by `longer_fr-`, but if the filter yields an empty set,
             // we fall back to the original one.
-            let subset: Vec<_> = shorter_fr_plus
+            let subset: Vec<_> = constraints
                 .iter()
-                .filter(|&&fr_plus| self.eval_outlives(fr_minus, fr_plus))
+                .filter(|&&(fr_minus, shorter_fr_plus)| {
+                    self.eval_outlives(fr_minus, shorter_fr_plus)
+                })
                 .copied()
                 .collect();
-            let shorter_fr_plus = if subset.is_empty() { shorter_fr_plus } else { subset };
-            debug!("try_propagate_universal_region_error: shorter_fr_plus={:?}", shorter_fr_plus);
-            for fr in shorter_fr_plus {
-                // Push the constraint `fr-: shorter_fr+`
+            let propagated_constraints = if subset.is_empty() { constraints } else { subset };
+            debug!(
+                "try_propagate_universal_region_error: constraints={:?}",
+                propagated_constraints
+            );
+
+            for (fr_minus, fr_plus) in propagated_constraints {
+                // Push the constraint `long_fr-: shorter_fr+`
                 propagated_outlives_requirements.push(ClosureOutlivesRequirement {
                     subject: ClosureOutlivesSubject::Region(fr_minus),
-                    outlived_free_region: fr,
+                    outlived_free_region: fr_plus,
                     blame_span: blame_constraint.cause.span,
                     category: blame_constraint.category,
                 });

compiler/rustc_borrowck/src/type_check/free_region_relations.rs

@@ -94,28 +94,10 @@ impl UniversalRegionRelations<'_> {
     /// words, returns the largest (*) known region `fr1` that (a) is
     /// outlived by `fr` and (b) is not local.
     ///
-    /// (*) If there are multiple competing choices, we pick the "postdominating"
-    /// one. See `TransitiveRelation::postdom_upper_bound` for details.
-    pub(crate) fn non_local_lower_bound(&self, fr: RegionVid) -> Option<RegionVid> {
+    /// (*) If there are multiple competing choices, we return all of them.
+    pub(crate) fn non_local_lower_bounds(&self, fr: RegionVid) -> Vec<RegionVid> {
         debug!("non_local_lower_bound(fr={:?})", fr);
-        let lower_bounds = self.non_local_bounds(&self.outlives, fr);
-
-        // In case we find more than one, reduce to one for
-        // convenience. This is to prevent us from generating more
-        // complex constraints, but it will cause spurious errors.
-        let post_dom = self.outlives.mutual_immediate_postdominator(lower_bounds);
-
-        debug!("non_local_bound: post_dom={:?}", post_dom);
-
-        post_dom.and_then(|post_dom| {
-            // If the mutual immediate postdom is not local, then
-            // there is no non-local result we can return.
-            if !self.universal_regions.is_local_free_region(post_dom) {
-                Some(post_dom)
-            } else {
-                None
-            }
-        })
+        self.non_local_bounds(&self.outlives, fr)
     }
 
     /// Helper for `non_local_upper_bounds` and `non_local_lower_bounds`.