make type_must_be_valid_for_scope require each region to outlive S

This is compatible with the liveness rules for NLL; it is also
stricter than the old requirement. It gives enough guidance to get
inference passing.

Author: nikomatsakis

src/librustc_typeck/check/regionck.rs

@@ -1034,14 +1034,19 @@ impl<'a, 'gcx, 'tcx> RegionCtxt<'a, 'gcx, 'tcx> {
     /// implies `T: scope` but is actually stronger than that in the
     /// case of projections. This helps overcome some weakenesses in
     /// our inference (see #55756).
+    ///
+    /// (This is the lexical equivalent of NLL's "liveness rules",
+    /// which require that any region which appears at the point P
+    /// must contain the point P.)
     pub fn type_must_be_valid_for_scope(
         &self,
         origin: infer::SubregionOrigin<'tcx>,
         ty: Ty<'tcx>,
         scope: region::Scope,
     ) {
-        let region = self.tcx.mk_region(ty::ReScope(scope));
-        self.type_must_outlive(origin, ty, region)
+        let scope_region = self.tcx.mk_region(ty::ReScope(scope));
+        let ty = self.resolve_type_vars_if_possible(&ty);
+        self.tcx.for_each_free_region(&ty, |ty_region| self.sub_regions(origin.clone(), scope_region, ty_region));
     }
 
     /// Adds constraints to inference such that `T: 'a` holds (or

src/test/ui/issues/issue-55756.rs

@@ -0,0 +1,47 @@
+// Regression test for #55756.
+//
+// In this test, the result of `self.callee` is a projection `<D as
+// Database<'?0>>::Guard`. As it may contain a destructor, the dropck
+// rules require that this type outlivess the scope of `state`. Unfortunately,
+// our region inference is not smart enough to figure out how to
+// translate a requirement like
+//
+//     <D as Database<'0>>::guard: 'r
+//
+// into a requirement that `'0: 'r` -- in particular, it fails to do
+// so because it *also* knows that `<D as Database<'a>>::Guard: 'a`
+// from the trait definition. Faced with so many choices, the current
+// solver opts to do nothing.
+//
+// The problem we were having was that we would observe two
+// potentially applicable rules when trying to find bounds for `<T as
+// Database<'0>>::Guard`:
+//
+// ```
+// <T as Database<'a>>::Guard: 'a // from the where clauses
+// for<'b> { <T as Database<'b>>::Guard: 'b } // from the trait definition
+// ```
+//
+// Because of this, we decided to take no action to influence
+// inference, which means that `'0` winds up unconstrained, leading to
+// the ultimate error.
+//
+// compile-pass
+
+#![crate_type="lib"]
+
+pub trait Database<'a> {
+    type Guard: 'a;
+}
+
+pub struct Stateful<'a, D: 'a>(&'a D);
+
+impl<'b, D: for <'a> Database<'a>> Stateful<'b, D> {
+    pub fn callee<'a>(&'a self) -> <D as Database<'a>>::Guard {
+        unimplemented!()
+    }
+    pub fn caller<'a>(&'a self) -> <D as Database<'a>>::Guard {
+        let state = self.callee();
+        self.callee()
+    }
+}