Cover type outlives handling in the minimal coroutine mode

The shared binder tests only exercised region outlives constraints, and
the two alias cases assert on the rewrite that the full mode performs,
which the minimal mode deliberately skips.

Add a case where an assumption names the component while the goal names
the composite. Keeping the constraint whole leaves it for the root, and
destructuring it would reduce it to the component and discharge it, so
the two representations disagree. Also record that an assumption naming
an alias exactly fails to discharge it, because assumptions are lowered
without normalization and so compare unequal to the normalized goal.

Author: Dnreikronos

tests/ui/assumptions_on_binders/min-coroutines-alias-outlives.rs

@@ -0,0 +1,47 @@
+//@ compile-flags: -Zassumptions-on-binders=min_coroutines
+//@ normalize-stderr: "\[[0-9a-f]{4}\]" -> "[HASH]"
+
+#![feature(test_binder_constraints)]
+#![allow(internal_features)]
+
+trait Trait {
+    type Assoc;
+}
+
+// Minimal mode keeps type outlives constraints intact instead of destructuring them into their
+// components, so these constraints are retained and left for the root inference context.
+//
+// The `actual` constraint in the expected output is the point of these tests, so do not normalize
+// it away: it is what distinguishes the retained `TypeOutlives` leaf from the OR of item bounds,
+// env assumptions and components that eager destructuring would produce.
+
+// The assumption names the component `T` while the goal names the composite `(T,)`. Destructuring
+// eagerly would reduce the goal to its component and discharge it against the assumption, which is
+// exactly the strengthening of the eager leak check that this mode avoids. Keeping the constraint
+// whole means it is retained instead, so this `expect` clause fails.
+core::test_binder_constraints! {
+    impl<T> {
+        forall<'a> where T: 'a {
+            //~^ ERROR forall expect clause failed
+            where (T,): 'a
+        } expect {}
+    }
+}
+
+// FIXME(-Zassumptions-on-binders): the assumption on the binder names the very same alias, so this
+// ought to be discharged and the `expect` clause ought to hold. It is not, because the assumption
+// is lowered without being normalized and so carries a non-rigid alias, while the goal is
+// normalized to a rigid one, and the two do not compare equal. See the FIXME about normalizing
+// assumptions in `region_assumptions_for_placeholders_in_universe`. Destructuring the constraint
+// eagerly would lose the `TypeOutlives` leaf that this matching needs, which is why minimal mode
+// keeps it.
+core::test_binder_constraints! {
+    impl<T: Trait> {
+        forall<'a> where T::Assoc: 'a {
+            //~^ ERROR forall expect clause failed
+            where T::Assoc: 'a
+        } expect {}
+    }
+}
+
+fn main() {}

tests/ui/assumptions_on_binders/min-coroutines-alias-outlives.stderr

@@ -0,0 +1,61 @@
+error: forall expect clause failed
+  --> $DIR/min-coroutines-alias-outlives.rs:24:9
+   |
+LL |         forall<'a> where T: 'a {
+   |         ^^^^^^
+   |
+note: constraint from here
+  --> $DIR/min-coroutines-alias-outlives.rs:24:9
+   |
+LL |         forall<'a> where T: 'a {
+   |         ^^^^^^
+   = note: expected: And(
+               [],
+           )
+   = note: actual: And(
+               [
+                   TypeOutlives(
+                       (T/#0,),
+                       '!1_0.Named(DefId(0:8 ~ min_coroutines_alias_outlives[HASH]::{test_binder_constraints#0}::'a)),
+                       $DIR/min-coroutines-alias-outlives.rs:24:9: 24:15 (#0),
+                   ),
+               ],
+           )
+
+error: forall expect clause failed
+  --> $DIR/min-coroutines-alias-outlives.rs:40:9
+   |
+LL |         forall<'a> where T::Assoc: 'a {
+   |         ^^^^^^
+   |
+note: constraint from here
+  --> $DIR/min-coroutines-alias-outlives.rs:40:9
+   |
+LL |         forall<'a> where T::Assoc: 'a {
+   |         ^^^^^^
+   = note: expected: And(
+               [],
+           )
+   = note: actual: And(
+               [
+                   TypeOutlives(
+                       Alias(
+                           Yes,
+                           Alias {
+                               kind: Projection {
+                                   def_id: DefId(0:4 ~ min_coroutines_alias_outlives[HASH]::Trait::Assoc),
+                               },
+                               args: [
+                                   T/#0,
+                               ],
+                               ..
+                           },
+                       ),
+                       '!1_0.Named(DefId(0:11 ~ min_coroutines_alias_outlives[HASH]::{test_binder_constraints#1}::'a)),
+                       $DIR/min-coroutines-alias-outlives.rs:40:9: 40:15 (#0),
+                   ),
+               ],
+           )
+
+error: aborting due to 2 previous errors
+

tests/ui/assumptions_on_binders/test-infra-works.rs

@@ -52,7 +52,15 @@ trait Trait {
 // `impl` should fail because the constraints asserted in `expect` should fail to prove true. Might
 // be https://github.com/rust-lang/project-assumptions-on-binders/issues/26
 //
+// The `expect` clauses of this and the next test assert on the full mode's rewrite of alias
+// outlives constraints into lower universes. `min_coroutines` deliberately does not rewrite, it
+// only drops constraints directly implied by the binder's assumptions and keeps the rest as they
+// are, so the rewritten form is specific to `assumptions`. The retained form cannot be spelled in
+// an `expect` clause because it still mentions the binder's own lifetime, so `min_coroutines`
+// coverage for aliases lives in `min-coroutines-alias-outlives.rs` instead.
+//
 // for<> syntax does direct insert into constraint storage
+#[cfg(assumptions)]
 core::test_binder_constraints! {
     impl<T: Trait> {
         forall<'a> {
@@ -71,6 +79,7 @@ core::test_binder_constraints! {
 // be https://github.com/rust-lang/project-assumptions-on-binders/issues/26
 //
 // `where` syntax goes through the full clause destructuring and register_obligation pipeline
+#[cfg(assumptions)]
 core::test_binder_constraints! {
     impl<T: Trait> {
         forall<'a> {
@@ -96,4 +105,16 @@ core::test_binder_constraints! {
     }
 }
 
+// Minimal mode discharges a type outlives goal when an assumption names the same type. Note that
+// this case alone does not pin down whether the constraint was kept whole or destructured, since a
+// bare param is its own only component either way; `min-coroutines-alias-outlives.rs` covers that.
+#[cfg(min_coroutines)]
+core::test_binder_constraints! {
+    impl<T> {
+        forall<'a> where T: 'a {
+            where T: 'a
+        } expect {}
+    }
+}
+
 fn main() {}