member constraints: support existential regions from non-root universes

Author: lcnr

compiler/rustc_borrowck/src/region_infer/opaque_types.rs

@@ -311,6 +311,7 @@ fn apply_member_constraints<'tcx>(
         defining_use.hidden_type.ty.visit_with(&mut visitor);
     }
 
+    debug!(?member_constraints);
     for scc_a in rcx.constraint_sccs.all_sccs() {
         debug!(?scc_a);
         for &scc_b in rcx.constraint_sccs.successors(scc_a) {
@@ -324,18 +325,12 @@ fn apply_member_constraints<'tcx>(
     }
 }
 
+#[instrument(level = "debug", skip(rcx))]
 fn apply_member_constraint<'tcx>(
     rcx: &mut RegionCtxt<'_, 'tcx>,
     member: ConstraintSccIndex,
     arg_regions: &[RegionVid],
 ) {
-    // If the member region lives in a higher universe, we currently choose
-    // the most conservative option by leaving it unchanged.
-    if !rcx.annotations[member].min_universe().is_root() {
-        debug!("member not in root universe");
-        return;
-    }
-
     // The existing value of `'member` is a lower-bound. If its is already larger than
     // some universal region, we cannot equate it with that region. Said differently, we
     // ignore choice regions which are smaller than this member region.
@@ -424,7 +419,6 @@ impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for CollectMemberConstraintsVisitor<'_, '_,
     //
     // If there's a unique minimum choice, we emit a `'member: 'min_choice` constraint.
     // Note that we do not require the two regions to be equal... TODO examples
-    #[instrument(level = "debug", skip(self))]
     fn visit_region(&mut self, r: Region<'tcx>) {
         match r.kind() {
             ty::ReBound(..) => return,

tests/ui/nll/member-constraints/non-root-universe-existential-1.rs

@@ -0,0 +1,31 @@
+//@ check-pass
+//@ revisions: current next
+//@ ignore-compare-mode-next-solver (explicit revisions)
+//@[next] compile-flags: -Znext-solver
+
+trait Proj<'a> {
+    type Assoc;
+}
+
+impl<'a, 'b, F: FnOnce() -> &'b ()> Proj<'a> for F {
+    type Assoc = ();
+}
+
+fn is_proj<F: for<'a> Proj<'a>>(f: F) {}
+
+fn define<'a>() -> impl Sized + use<'a> {
+    // This defines the RPIT to `&'unconstrained_b ()`, an inference
+    // variable which is in a higher universe as gets created inside
+    // of the binder of `F: for<'a> Proj<'a>`. This previously caused
+    // us to not apply member constraints.
+    //
+    // This was unnecessary. It is totally acceptable for member regions
+    // to be able to name placeholders from higher universes, as long as
+    // they don't actually do so.
+    is_proj(define::<'a>);
+    &()
+}
+
+fn main() {}
+
+

tests/ui/nll/member-constraints/non-root-universe-existential-2.rs

@@ -0,0 +1,31 @@
+//@ check-pass
+
+// Unlike `non-root-universe-existential-1.rs` this previously
+// compiled. We didn't attempt to define the hidden type of
+// `impl Iterator` when projecting through it. We now do. Further
+// minimizing this is challenging.
+
+struct Type(Vec<Type>);
+enum TypeTreeValueIter<'a, T> {
+    Once(T),
+    Ref(&'a ()),
+}
+
+impl<'a, T> Iterator for TypeTreeValueIter<'a, T> {
+    type Item = T;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        loop {}
+    }
+}
+
+fn item<I: Iterator<Item: Iterator>>(x: I) -> <I::Item as Iterator>::Item {
+    loop {}
+}
+
+fn get_type_tree_values<'a>(ty: &'a Type) -> impl Iterator<Item = &'a Type> {
+    let _: &'a Type = item(std::iter::once(ty).map(get_type_tree_values));
+    TypeTreeValueIter::<'a, &'a Type>::Once(ty)
+}
+
+fn main() {}