Do not propogate unnecessary closure constraints + tests.

Author: LorrensP-2158466

compiler/rustc_borrowck/src/region_infer/mod.rs

@@ -1290,17 +1290,44 @@ impl<'tcx> RegionInferenceContext<'tcx> {
             // Grow `shorter_fr` until we find some non-local regions. (We
             // always will.)  We'll call them `shorter_fr+` -- they're ever
             // so slightly larger than `shorter_fr`.
-            let shorter_fr_plus =
+            let shorter_fr_plusses =
                 self.universal_region_relations.non_local_upper_bounds(shorter_fr);
-            debug!("try_propagate_universal_region_error: shorter_fr_plus={:?}", shorter_fr_plus);
-            for fr in shorter_fr_plus {
-                // Push the constraint `fr-: shorter_fr+`
-                propagated_outlives_requirements.push(ClosureOutlivesRequirement {
-                    subject: ClosureOutlivesSubject::Region(fr_minus),
-                    outlived_free_region: fr,
-                    blame_span: blame_constraint.cause.span,
-                    category: blame_constraint.category,
-                });
+            debug!(
+                "try_propagate_universal_region_error: shorter_fr_plus={:?}",
+                shorter_fr_plusses
+            );
+
+            let fr_static = self.universal_regions().fr_static;
+            let single_region = shorter_fr_plusses.len() == 1;
+
+            for shorter_fr_plus in shorter_fr_plusses {
+                // Don't propagate every `fr-: shorter_fr+`.
+                // A smaller "optimal subset" exists, since full propagation is overly conservative
+                // and can reject valid code. Consider this small example (`'b: 'a` == `a -> b`)
+                // were we try to propagate region error `'d: 'a`:
+                // a --> b --> d
+                //  \
+                //   \-> c
+                // Here `shorter_fr_plusses` == `['b, 'c]`.
+                // Propagating `'d: 'b` is correct and should happen; `'d: 'c` is redundant and can reject valid code.
+                // We can come closer to this "optimal subset" by checking if the `shorter_fr+` should be outlived by `fr-`.
+                // NOTE: [] is *not* a valid subset, so we check for that as well.
+                if single_region
+                    || shorter_fr_plus == fr_static // `fr-: 'static` should be propagated
+                    || self.eval_outlives(fr_minus, shorter_fr_plus)
+                {
+                    debug!(
+                        "try_propagate_universal_region_error: propagating {:?}: {:?}",
+                        fr_minus, shorter_fr_plus,
+                    );
+                    // If that's the case, push the constraint `fr-: shorter_fr+`
+                    propagated_outlives_requirements.push(ClosureOutlivesRequirement {
+                        subject: ClosureOutlivesSubject::Region(fr_minus),
+                        outlived_free_region: shorter_fr_plus,
+                        blame_span: blame_constraint.cause.span,
+                        category: blame_constraint.category,
+                    });
+                }
             }
             return RegionRelationCheckResult::Propagated;
         }

tests/ui/regions/closure-prop-issue-104477-case1.rs

@@ -0,0 +1,11 @@
+//@ check-pass
+
+
+struct MyTy<'x, 'a, 'b>(std::cell::Cell<(&'x &'a u8, &'x &'b u8)>);
+fn wf<T>(_: T) {}
+fn test<'a, 'b>() {
+    |_: &'a u8, x: MyTy<'_, 'a, 'b>| wf(x);
+    |x: MyTy<'_, 'a, 'b>, _: &'a u8| wf(x);
+}
+
+fn main(){}

tests/ui/regions/closure-prop-issue-148289.rs

@@ -0,0 +1,22 @@
+//@ check-pass
+
+#[derive(Clone, Copy)]
+struct Inv<'a>(*mut &'a ());
+impl<'a> Inv<'a> {
+    fn outlived_by<'b: 'a>(self, _: Inv<'b>) {}
+}
+struct OutlivedBy<'a, 'b: 'a>(Inv<'a>, Inv<'b>);
+
+fn closure_arg<'b, 'c, 'd>(
+    _: impl for<'a> FnOnce(Inv<'a>, OutlivedBy<'a, 'b>, OutlivedBy<'a, 'c>, Inv<'d>),
+) {
+}
+fn foo<'b, 'c, 'd: 'b>() {
+    closure_arg::<'b, 'c, 'd>(|a, b, c, d| {
+        a.outlived_by(b.1);
+        a.outlived_by(c.1);
+        b.1.outlived_by(d);
+    });
+}
+
+fn main() {}